deepctl-cmd-debug-browser 0.1.0__tar.gz

deepctl_cmd_debug_browser-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: deepctl-cmd-debug-browser
+Version: 0.1.0
+Summary: Browser debug subcommand for deepctl
+Author-email: Deepgram <devrel@deepgram.com>
+Maintainer-email: Deepgram <devrel@deepgram.com>
+License-Expression: MIT
+Keywords: deepgram,cli,debug,browser,diagnostics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: deepctl-core>=0.1.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+
+# deepctl-cmd-debug-browser
+
+Browser debug subcommand for the Deepgram CLI (deepctl). This package provides the `browser` subcommand under the `debug` command group, allowing users to debug browser-related issues when using Deepgram's web-based features

deepctl_cmd_debug_browser-0.1.0/README.md

@@ -0,0 +1,3 @@
+# deepctl-cmd-debug-browser
+
+Browser debug subcommand for the Deepgram CLI (deepctl). This package provides the `browser` subcommand under the `debug` command group, allowing users to debug browser-related issues when using Deepgram's web-based features

deepctl_cmd_debug_browser-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deepctl-cmd-debug-browser"
+version = "0.1.0"
+description = "Browser debug subcommand for deepctl"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Deepgram", email = "devrel@deepgram.com" }]
+maintainers = [{ name = "Deepgram", email = "devrel@deepgram.com" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+keywords = ["deepgram", "cli", "debug", "browser", "diagnostics"]
+requires-python = ">=3.10"
+dependencies = [
+    "deepctl-core>=0.1.0",
+    "click>=8.0.0",
+    "rich>=13.0.0",
+    "pydantic>=2.0.0",
+    "httpx>=0.24.0",
+    "aiohttp>=3.9.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0.0", "pytest-asyncio>=0.21.0"]
+
+[project.scripts]
+# Internal commands not meant to be called directly
+
+[project.entry-points."deepctl.subcommands.debug"]
+browser = "deepctl_cmd_debug_browser.command:BrowserCommand"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["deepctl_cmd_debug_browser*"]
+
+[tool.setuptools.package-data]
+deepctl_cmd_debug_browser = ["static/*.html"]

deepctl_cmd_debug_browser-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser/__init__.py

@@ -0,0 +1,11 @@
+"""Browser debug subcommand for deepctl."""
+
+from .command import BrowserCommand
+from .models import BrowserCapabilities, BrowserCapability, BrowserDebugResult
+
+__all__ = [
+    "BrowserCapabilities",
+    "BrowserCapability",
+    "BrowserCommand",
+    "BrowserDebugResult",
+]

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser/command.py

@@ -0,0 +1,445 @@
+"""Browser debug command for deepctl."""
+
+import asyncio
+import importlib.resources
+import json
+import socket
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any
+
+from aiohttp import WSMsgType, web
+from deepctl_core import AuthManager, BaseCommand, Config, DeepgramClient
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from .models import (
+    BrowserCapabilities,
+    BrowserCapability,
+    BrowserDebugResult,
+    MessageType,
+    WebSocketMessage,
+)
+
+console = Console()
+
+
+class BrowserCommand(BaseCommand):
+    """Debug browser-related connectivity and access issues."""
+
+    name = "browser"
+    help = "Debug browser compatibility and capabilities for Deepgram services"
+    short_help = "Debug browser capabilities"
+
+    # Browser debug doesn't require auth
+    requires_auth = False
+    requires_project = False
+    ci_friendly = False  # This command opens a browser
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.messages: list[WebSocketMessage] = []
+        self.capabilities_data: dict[str, Any] = {}
+        self.ws_clients: set[Any] = set()
+        self.debug_complete = False
+        self.start_time: float | None = None
+
+    def get_arguments(self) -> list[dict[str, Any]]:
+        """Get command arguments and options."""
+        return [
+            {
+                "names": ["--port", "-p"],
+                "help": (
+                    "Port to run the debug server on "
+                    "(default: auto-select starting from 3000)"
+                ),
+                "type": int,
+                "is_option": True,
+            },
+            {
+                "names": ["--no-browser"],
+                "help": "Don't automatically open the browser",
+                "is_flag": True,
+                "is_option": True,
+            },
+            {
+                "names": ["--timeout"],
+                "help": (
+                    "Timeout in seconds to wait for browser connection "
+                    "(default: 60)"
+                ),
+                "type": int,
+                "default": 60,
+                "is_option": True,
+            },
+        ]
+
+    def find_available_port(self, start_port: int = 3000) -> int:
+        """Find an available port starting from the given port."""
+        for port in range(start_port, start_port + 100):
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                sock.bind(("localhost", port))
+                sock.close()
+                return port
+            except OSError:
+                continue
+        raise RuntimeError(
+            f"Could not find available port starting from {start_port}"
+        )
+
+    async def websocket_handler(self, request: Any) -> Any:
+        """Handle WebSocket connections from the browser."""
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+        self.ws_clients.add(ws)
+
+        try:
+            async for msg in ws:
+                if msg.type == WSMsgType.TEXT:
+                    data = json.loads(msg.data)
+                    ws_msg = WebSocketMessage(
+                        type=MessageType(data.get("type", "info")),
+                        data=data.get("data", {}),
+                        message=data.get("message"),
+                    )
+                    self.messages.append(ws_msg)
+
+                    # Handle different message types
+                    if ws_msg.type == MessageType.CAPABILITY_CHECK:
+                        cap_data = ws_msg.data.get("result", {})
+                        cap_key = ws_msg.data.get("capability")
+                        if cap_key and cap_data:
+                            self.capabilities_data[cap_key] = (
+                                BrowserCapability(**cap_data)
+                            )
+
+                    elif ws_msg.type == MessageType.COMPLETE:
+                        # Store complete capabilities
+                        if "capabilities" in ws_msg.data:
+                            caps = ws_msg.data["capabilities"]
+                            # Convert all capability data
+                            cap_dict = {}
+                            for key in [
+                                "web_audio_api",
+                                "audio_context",
+                                "audio_worklet",
+                                "websocket_api",
+                                "fetch_api",
+                                "es6_features",
+                                "dom_apis",
+                                "console_api",
+                                "timer_apis",
+                                "secure_context",
+                            ]:
+                                if key in caps:
+                                    cap_dict[key] = BrowserCapability(
+                                        **caps[key]
+                                    )
+                                elif key in self.capabilities_data:
+                                    cap_dict[key] = self.capabilities_data[key]
+
+                            # Store complete capabilities
+                            self.capabilities_data = {
+                                **cap_dict,
+                                "user_agent": caps.get(
+                                    "user_agent", "Unknown"
+                                ),
+                                "overall_compatible": caps.get(
+                                    "overall_compatible", False
+                                ),
+                            }
+                        self.debug_complete = True
+                elif msg.type == WSMsgType.ERROR:
+                    console.print(
+                        f"[red]WebSocket error: {ws.exception()}[/red]"
+                    )
+        finally:
+            self.ws_clients.discard(ws)
+            await ws.close()
+
+        return ws
+
+    async def http_handler(self, request: Any) -> Any:
+        """Serve the debug HTML page."""
+        if request.path == "/":
+            # Read the HTML template from the static directory
+            try:
+                files = importlib.resources.files("deepctl_cmd_debug_browser")
+                html_content = (files / "static" / "debug.html").read_text()
+            except Exception:
+                # Fallback to Path-based approach
+                html_path = Path(__file__).parent / "static" / "debug.html"
+                html_content = html_path.read_text()
+
+            return web.Response(text=html_content, content_type="text/html")
+        return web.Response(status=404)
+
+    async def run_servers(self, port: int, timeout: int) -> dict[str, Any]:
+        """Run both HTTP and WebSocket servers."""
+        # Create aiohttp app
+        app = web.Application()
+        app.router.add_get("/", self.http_handler)
+        app.router.add_get("/ws", self.websocket_handler)
+
+        # Start HTTP server (which also handles WebSocket)
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, "localhost", port)
+        await site.start()
+
+        console.print(
+            f"\n[green]✓[/green] Debug server started on port "
+            f"[cyan]{port}[/cyan]"
+        )
+
+        # Wait for debug to complete or timeout
+        start_time = time.time()
+        while not self.debug_complete and (time.time() - start_time) < timeout:
+            await asyncio.sleep(0.1)
+
+        # Cleanup
+        await runner.cleanup()
+
+        return {
+            "completed": self.debug_complete,
+            "timed_out": not self.debug_complete
+            and (time.time() - start_time) >= timeout,
+            "duration": time.time() - start_time,
+        }
+
+    def display_results(
+        self,
+        capabilities: BrowserCapabilities | None,
+        messages: list[WebSocketMessage],
+    ) -> None:
+        """Display the debug results in a formatted way."""
+        console.print("\n[bold cyan]Browser Debug Results[/bold cyan]\n")
+
+        # Display messages/logs
+        if messages:
+            log_table = Table(
+                title="Debug Log", show_header=True, header_style="bold cyan"
+            )
+            log_table.add_column("Time", style="dim", width=12)
+            log_table.add_column("Type", width=10)
+            log_table.add_column("Message")
+
+            for msg in messages:
+                if msg.message:
+                    time_str = msg.timestamp.strftime("%H:%M:%S.%f")[:-3]
+                    type_style = {
+                        MessageType.ERROR: "red",
+                        MessageType.WARNING: "yellow",
+                        MessageType.INFO: "cyan",
+                        MessageType.CAPABILITY_CHECK: "green",
+                        MessageType.COMPLETE: "magenta",
+                    }.get(msg.type, "white")
+
+                    log_table.add_row(
+                        time_str,
+                        f"[{type_style}]{msg.type.value}[/{type_style}]",
+                        msg.message or "",
+                    )
+
+            console.print(log_table)
+            console.print()
+
+        # Display capabilities
+        if capabilities:
+            cap_table = Table(
+                title="Browser Capabilities",
+                show_header=True,
+                header_style="bold cyan",
+            )
+            cap_table.add_column("Feature", style="cyan", width=30)
+            cap_table.add_column("Status", width=15)
+            cap_table.add_column("Details", width=40)
+
+            # Add capability rows
+            capability_fields = [
+                ("web_audio_api", "Web Audio API"),
+                ("audio_context", "AudioContext"),
+                ("audio_worklet", "AudioWorklet API"),
+                ("websocket_api", "WebSocket API"),
+                ("fetch_api", "Fetch API"),
+                ("es6_features", "ES6+ Features"),
+                ("dom_apis", "DOM APIs"),
+                ("console_api", "Console API"),
+                ("timer_apis", "Timer APIs"),
+                ("secure_context", "Secure Context"),
+            ]
+
+            for field, display_name in capability_fields:
+                cap = getattr(capabilities, field, None)
+                if cap:
+                    status_icon = "✓" if cap.supported else "✗"
+                    status_color = "green" if cap.supported else "red"
+                    cap_table.add_row(
+                        display_name,
+                        f"[{status_color}]{status_icon} "
+                        f"{cap.details}[/{status_color}]",
+                        cap.version or "",
+                    )
+
+            console.print(cap_table)
+
+            # Overall compatibility
+            console.print(
+                f"\n[bold]User Agent:[/bold] {capabilities.user_agent}"
+            )
+            if capabilities.overall_compatible:
+                console.print(
+                    "[bold green]✓ Browser is fully compatible with "
+                    "Deepgram services[/bold green]"
+                )
+            else:
+                console.print(
+                    "[bold red]✗ Browser may have compatibility issues "
+                    "with some Deepgram features[/bold red]"
+                )
+
+    def handle(
+        self,
+        config: Config,
+        auth_manager: AuthManager,
+        client: DeepgramClient,
+        **kwargs: Any,
+    ) -> Any:
+        """Handle browser debug command execution."""
+        port = kwargs.get("port")
+        no_browser = kwargs.get("no_browser", False)
+        timeout = kwargs.get("timeout", 60)
+
+        self.start_time = time.time()
+
+        # Find available port
+        if not port:
+            port = self.find_available_port()
+
+        # Show initial message
+        console.print(
+            Panel.fit(
+                "[cyan]🌐 Browser Debug[/cyan]\n\n"
+                "Starting debug server to check browser capabilities...",
+                title="Deepctl Browser Debug",
+                border_style="cyan",
+            )
+        )
+
+        url = f"http://localhost:{port}"
+
+        # Prompt user to open browser
+        if not no_browser:
+            console.print(
+                "\n[yellow]Press Enter to open the debugger in your "
+                "browser...[/yellow]"
+            )
+            input()
+            webbrowser.open(url)
+            browser_opened = True
+        else:
+            console.print(
+                f"\n[dim]Open [cyan]{url}[/cyan] in your browser to start "
+                f"debugging[/dim]"
+            )
+            browser_opened = False
+
+        # Run the async event loop
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task(
+                "Waiting for browser connection...", total=None
+            )
+
+            # Run servers
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            try:
+                result = loop.run_until_complete(
+                    self.run_servers(port, timeout)
+                )
+            finally:
+                loop.close()
+
+            progress.update(task, completed=True)
+
+        # Process results
+        capabilities = None
+        if (
+            self.capabilities_data
+            and "overall_compatible" in self.capabilities_data
+        ):
+            # Build BrowserCapabilities object
+            cap_dict = {}
+            for key in [
+                "web_audio_api",
+                "audio_context",
+                "audio_worklet",
+                "websocket_api",
+                "fetch_api",
+                "es6_features",
+                "dom_apis",
+                "console_api",
+                "timer_apis",
+                "secure_context",
+            ]:
+                if key in self.capabilities_data:
+                    cap_dict[key] = self.capabilities_data[key]
+
+            if all(key in cap_dict for key in cap_dict):
+                capabilities = BrowserCapabilities(
+                    **cap_dict,
+                    user_agent=self.capabilities_data.get(
+                        "user_agent", "Unknown"
+                    ),
+                    overall_compatible=self.capabilities_data.get(
+                        "overall_compatible", False
+                    ),
+                )
+
+        # Display results
+        if result["completed"]:
+            console.print(
+                "\n[green]✓ Debug session completed successfully![/green]"
+            )
+            self.display_results(capabilities, self.messages)
+        elif result["timed_out"]:
+            console.print(
+                f"\n[red]✗ Debug session timed out after {timeout} "
+                f"seconds[/red]"
+            )
+            console.print("[dim]No browser connection was established.[/dim]")
+        else:
+            console.print("\n[yellow]Debug session ended[/yellow]")
+
+        # Build result
+        errors = [
+            msg.message
+            for msg in self.messages
+            if msg.type == MessageType.ERROR and msg.message
+        ]
+        warnings = [
+            msg.message
+            for msg in self.messages
+            if msg.type == MessageType.WARNING and msg.message
+        ]
+
+        return BrowserDebugResult(
+            status="success" if result["completed"] else "timeout",
+            port=port,
+            capabilities=capabilities,
+            messages=self.messages,
+            errors=errors,
+            warnings=warnings,
+            duration_seconds=result["duration"],
+            browser_opened=browser_opened,
+        )

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser/models.py

@@ -0,0 +1,72 @@
+"""Data models for browser debug command."""
+
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from deepctl_core import BaseResult
+from pydantic import BaseModel, Field, field_serializer
+
+
+class MessageType(str, Enum):
+    """Types of messages from the browser debugger."""
+
+    CAPABILITY_CHECK = "capability_check"
+    ERROR = "error"
+    INFO = "info"
+    WARNING = "warning"
+    COMPLETE = "complete"
+
+
+class BrowserCapability(BaseModel):
+    """Individual browser capability check result."""
+
+    name: str
+    supported: bool
+    version: str | None = None
+    details: str | None = None
+    required: bool = True
+
+
+class BrowserCapabilities(BaseModel):
+    """All browser capability check results."""
+
+    web_audio_api: BrowserCapability
+    audio_context: BrowserCapability
+    audio_worklet: BrowserCapability
+    websocket_api: BrowserCapability
+    fetch_api: BrowserCapability
+    es6_features: BrowserCapability
+    dom_apis: BrowserCapability
+    console_api: BrowserCapability
+    timer_apis: BrowserCapability
+    secure_context: BrowserCapability
+    user_agent: str
+    overall_compatible: bool
+
+
+class WebSocketMessage(BaseModel):
+    """Message received from the browser via WebSocket."""
+
+    type: MessageType
+    timestamp: datetime = Field(default_factory=datetime.now)
+    data: dict[str, Any]
+    message: str | None = None
+
+    @field_serializer("timestamp")
+    def serialize_timestamp(self, timestamp: datetime) -> str:
+        """Serialize datetime to ISO format string."""
+        return timestamp.isoformat()
+
+
+class BrowserDebugResult(BaseResult):
+    """Result from browser debug command execution."""
+
+    status: str = "success"
+    port: int
+    capabilities: BrowserCapabilities | None = None
+    messages: list[WebSocketMessage] = Field(default_factory=list)
+    errors: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
+    duration_seconds: float | None = None
+    browser_opened: bool = False

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser/static/__init__.py

@@ -0,0 +1,2 @@
+# This file makes the static directory a Python package for
+# importlib.resources compatibility

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser/static/debug.html

@@ -0,0 +1,507 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Deepctl Browser Debug</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: #0a0a0a;
+            color: #e0e0e0;
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            padding: 2rem;
+        }
+
+        .container {
+            max-width: 1000px;
+            margin: 0 auto;
+            width: 100%;
+        }
+
+        h1 {
+            font-size: 2.5rem;
+            margin-bottom: 1rem;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+
+        .subtitle {
+            color: #888;
+            margin-bottom: 2rem;
+            font-size: 1.1rem;
+        }
+
+        .status {
+            background: #1a1a1a;
+            border-radius: 12px;
+            padding: 1.5rem;
+            margin-bottom: 2rem;
+            border: 1px solid #333;
+        }
+
+        .status-item {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            margin-bottom: 0.5rem;
+        }
+
+        .indicator {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: #444;
+            transition: all 0.3s ease;
+        }
+
+        .indicator.success {
+            background: #4ade80;
+            box-shadow: 0 0 10px rgba(74, 222, 128, 0.5);
+        }
+
+        .indicator.error {
+            background: #f87171;
+            box-shadow: 0 0 10px rgba(248, 113, 113, 0.5);
+        }
+
+        .indicator.warning {
+            background: #fbbf24;
+            box-shadow: 0 0 10px rgba(251, 191, 36, 0.5);
+        }
+
+        .checks {
+            display: grid;
+            gap: 1rem;
+            margin-bottom: 2rem;
+        }
+
+        .check-item {
+            background: #1a1a1a;
+            border: 1px solid #333;
+            border-radius: 8px;
+            padding: 1rem 1.5rem;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            transition: all 0.3s ease;
+        }
+
+        .check-item:hover {
+            border-color: #555;
+            background: #222;
+        }
+
+        .check-name {
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .check-status {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            font-size: 0.9rem;
+        }
+
+        .check-status.success {
+            color: #4ade80;
+        }
+
+        .check-status.error {
+            color: #f87171;
+        }
+
+        .check-status.warning {
+            color: #fbbf24;
+        }
+
+        .progress {
+            width: 100%;
+            height: 6px;
+            background: #333;
+            border-radius: 3px;
+            overflow: hidden;
+            margin: 2rem 0;
+        }
+
+        .progress-bar {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            transition: width 0.3s ease;
+            width: 0%;
+        }
+
+        .log {
+            background: #0d0d0d;
+            border: 1px solid #333;
+            border-radius: 8px;
+            padding: 1rem;
+            max-height: 300px;
+            overflow-y: auto;
+            font-family: 'Courier New', monospace;
+            font-size: 0.9rem;
+            line-height: 1.5;
+        }
+
+        .log-entry {
+            margin-bottom: 0.5rem;
+            padding: 0.25rem 0;
+            border-bottom: 1px solid #222;
+        }
+
+        .log-entry:last-child {
+            border-bottom: none;
+        }
+
+        .timestamp {
+            color: #666;
+            font-size: 0.8rem;
+        }
+
+        .complete-message {
+            text-align: center;
+            padding: 2rem;
+            background: linear-gradient(135deg, rgba(102, 126, 234, 0.1) 0%, rgba(118, 75, 162, 0.1) 100%);
+            border-radius: 12px;
+            margin-top: 2rem;
+            display: none;
+        }
+
+        .complete-message.show {
+            display: block;
+        }
+
+        .loader {
+            width: 20px;
+            height: 20px;
+            border: 2px solid #333;
+            border-top-color: #667eea;
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+        }
+
+        @keyframes spin {
+            to {
+                transform: rotate(360deg);
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>Deepctl Browser Debug</h1>
+        <p class="subtitle">Running browser capability checks for Deepgram services...</p>
+
+        <div class="status">
+            <div class="status-item">
+                <div class="indicator" id="ws-indicator"></div>
+                <span>WebSocket Connection</span>
+            </div>
+        </div>
+
+        <div class="progress">
+            <div class="progress-bar" id="progress-bar"></div>
+        </div>
+
+        <div class="checks" id="checks">
+            <!-- Capability checks will be inserted here -->
+        </div>
+
+        <h3 style="margin-bottom: 1rem;">Debug Log</h3>
+        <div class="log" id="log"></div>
+
+        <div class="complete-message" id="complete-message">
+            <h2>Debug Complete!</h2>
+            <p style="margin-top: 1rem; color: #888;">You can close this window now.</p>
+        </div>
+    </div>
+
+    <script>
+        const WS_PORT = window.location.port;
+        const WS_URL = `ws://localhost:${WS_PORT}/ws`;
+
+        let ws = null;
+        let checkResults = {};
+        let totalChecks = 0;
+        let completedChecks = 0;
+
+        // Log function
+        function log(message, type = 'info') {
+            const logEl = document.getElementById('log');
+            const entry = document.createElement('div');
+            entry.className = 'log-entry';
+
+            const timestamp = new Date().toLocaleTimeString();
+            entry.innerHTML = `<span class="timestamp">[${timestamp}]</span> ${message}`;
+
+            logEl.appendChild(entry);
+            logEl.scrollTop = logEl.scrollHeight;
+
+            // Send to WebSocket
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: type,
+                    message: message,
+                    data: {}
+                }));
+            }
+        }
+
+        // Update progress
+        function updateProgress() {
+            const progress = (completedChecks / totalChecks) * 100;
+            document.getElementById('progress-bar').style.width = `${progress}%`;
+        }
+
+        // Connect to WebSocket
+        function connectWebSocket() {
+            log('Connecting to debug server...');
+
+            ws = new WebSocket(WS_URL);
+
+            ws.onopen = () => {
+                log('Connected to debug server', 'info');
+                document.getElementById('ws-indicator').className = 'indicator success';
+                startDebugChecks();
+            };
+
+            ws.onerror = (error) => {
+                log(`WebSocket error: ${error}`, 'error');
+                document.getElementById('ws-indicator').className = 'indicator error';
+            };
+
+            ws.onclose = () => {
+                log('Disconnected from debug server', 'info');
+                document.getElementById('ws-indicator').className = 'indicator error';
+            };
+        }
+
+        // Check browser capabilities
+        function startDebugChecks() {
+            log('Starting browser capability checks...');
+
+            const checks = [
+                {
+                    name: 'Web Audio API',
+                    key: 'web_audio_api',
+                    check: () => {
+                        return typeof window.AudioContext !== 'undefined' ||
+                            typeof window.webkitAudioContext !== 'undefined';
+                    }
+                },
+                {
+                    name: 'AudioContext',
+                    key: 'audio_context',
+                    check: () => {
+                        try {
+                            const AudioCtx = window.AudioContext || window.webkitAudioContext;
+                            const ctx = new AudioCtx();
+                            ctx.close();
+                            return true;
+                        } catch (e) {
+                            return false;
+                        }
+                    }
+                },
+                {
+                    name: 'AudioWorklet API',
+                    key: 'audio_worklet',
+                    check: async () => {
+                        try {
+                            const AudioCtx = window.AudioContext || window.webkitAudioContext;
+                            const ctx = new AudioCtx();
+                            const result = typeof ctx.audioWorklet !== 'undefined';
+                            ctx.close();
+                            return result;
+                        } catch (e) {
+                            return false;
+                        }
+                    }
+                },
+                {
+                    name: 'WebSocket API',
+                    key: 'websocket_api',
+                    check: () => typeof WebSocket !== 'undefined'
+                },
+                {
+                    name: 'Fetch API',
+                    key: 'fetch_api',
+                    check: () => typeof fetch !== 'undefined'
+                },
+                {
+                    name: 'ES6+ Features',
+                    key: 'es6_features',
+                    check: () => {
+                        try {
+                            // Test various ES6+ features
+                            eval('const a = 1; let b = 2; ');
+                            eval('const fn = async () => {}; ');
+                            eval('const arr = [1,2,3]; const [...rest] = arr; ');
+                            eval('class Test {}');
+                            return true;
+                        } catch (e) {
+                            return false;
+                        }
+                    }
+                },
+                {
+                    name: 'DOM APIs',
+                    key: 'dom_apis',
+                    check: () => {
+                        return typeof document.createElement !== 'undefined' &&
+                            typeof window.location !== 'undefined' &&
+                            typeof document.head !== 'undefined';
+                    }
+                },
+                {
+                    name: 'Console API',
+                    key: 'console_api',
+                    check: () => {
+                        return typeof console !== 'undefined' &&
+                            typeof console.log === 'function' &&
+                            typeof console.error === 'function';
+                    }
+                },
+                {
+                    name: 'Timer APIs',
+                    key: 'timer_apis',
+                    check: () => {
+                        return typeof setTimeout === 'function' &&
+                            typeof clearTimeout === 'function' &&
+                            typeof setInterval === 'function';
+                    }
+                },
+                {
+                    name: 'Secure Context (HTTPS/localhost)',
+                    key: 'secure_context',
+                    check: () => window.isSecureContext === true
+                }
+            ];
+
+            totalChecks = checks.length;
+            const checksContainer = document.getElementById('checks');
+
+            // Create UI for each check
+            checks.forEach(check => {
+                const checkEl = document.createElement('div');
+                checkEl.className = 'check-item';
+                checkEl.id = `check-${check.key}`;
+                checkEl.innerHTML = `
+                    <div class="check-name">
+                        <div class="loader" id="loader-${check.key}"></div>
+                        ${check.name}
+                    </div>
+                    <div class="check-status" id="status-${check.key}">
+                        Checking...
+                    </div>
+                `;
+                checksContainer.appendChild(checkEl);
+            });
+
+            // Run checks
+            checks.forEach(async (check, index) => {
+                setTimeout(async () => {
+                    try {
+                        const result = await check.check();
+                        const loaderEl = document.getElementById(`loader-${check.key}`);
+                        const statusEl = document.getElementById(`status-${check.key}`);
+
+                        checkResults[check.key] = {
+                            name: check.name,
+                            supported: result,
+                            version: null,
+                            details: result ? 'Supported' : 'Not supported',
+                            required: true
+                        };
+
+                        if (result) {
+                            loaderEl.className = 'indicator success';
+                            statusEl.className = 'check-status success';
+                            statusEl.textContent = '✓ Supported';
+                            log(`${check.name}: Supported`, 'info');
+                        } else {
+                            loaderEl.className = 'indicator error';
+                            statusEl.className = 'check-status error';
+                            statusEl.textContent = '✗ Not Supported';
+                            log(`${check.name}: Not supported`, 'error');
+                        }
+
+                        completedChecks++;
+                        updateProgress();
+
+                        // Send result to server
+                        if (ws && ws.readyState === WebSocket.OPEN) {
+                            ws.send(JSON.stringify({
+                                type: 'capability_check',
+                                data: {
+                                    capability: check.key,
+                                    result: checkResults[check.key]
+                                }
+                            }));
+                        }
+
+                        // Check if all tests are complete
+                        if (completedChecks === totalChecks) {
+                            completeDebug();
+                        }
+                    } catch (error) {
+                        log(`Error checking ${check.name}: ${error.message}`, 'error');
+                        completedChecks++;
+                        updateProgress();
+                    }
+                }, index * 200); // Stagger checks for visual effect
+            });
+        }
+
+        // Complete debug session
+        function completeDebug() {
+            log('All capability checks complete!', 'info');
+
+            const overallCompatible = Object.values(checkResults).every(r => r.supported);
+
+            // Send final results
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'complete',
+                    data: {
+                        capabilities: {
+                            ...checkResults,
+                            user_agent: navigator.userAgent,
+                            overall_compatible: overallCompatible
+                        }
+                    }
+                }));
+
+                // Close WebSocket after a short delay
+                setTimeout(() => {
+                    ws.close();
+                }, 1000);
+            }
+
+            // Show completion message
+            document.getElementById('complete-message').className = 'complete-message show';
+        }
+
+        // Initialize
+        document.addEventListener('DOMContentLoaded', () => {
+            connectWebSocket();
+        });
+    </script>
+</body>
+
+</html>

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: deepctl-cmd-debug-browser
+Version: 0.1.0
+Summary: Browser debug subcommand for deepctl
+Author-email: Deepgram <devrel@deepgram.com>
+Maintainer-email: Deepgram <devrel@deepgram.com>
+License-Expression: MIT
+Keywords: deepgram,cli,debug,browser,diagnostics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: deepctl-core>=0.1.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+
+# deepctl-cmd-debug-browser
+
+Browser debug subcommand for the Deepgram CLI (deepctl). This package provides the `browser` subcommand under the `debug` command group, allowing users to debug browser-related issues when using Deepgram's web-based features

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/deepctl_cmd_debug_browser/__init__.py
+src/deepctl_cmd_debug_browser/command.py
+src/deepctl_cmd_debug_browser/models.py
+src/deepctl_cmd_debug_browser.egg-info/PKG-INFO
+src/deepctl_cmd_debug_browser.egg-info/SOURCES.txt
+src/deepctl_cmd_debug_browser.egg-info/dependency_links.txt
+src/deepctl_cmd_debug_browser.egg-info/entry_points.txt
+src/deepctl_cmd_debug_browser.egg-info/requires.txt
+src/deepctl_cmd_debug_browser.egg-info/top_level.txt
+src/deepctl_cmd_debug_browser/static/__init__.py
+src/deepctl_cmd_debug_browser/static/debug.html

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[deepctl.subcommands.debug]
+browser = deepctl_cmd_debug_browser.command:BrowserCommand

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/requires.txt

@@ -0,0 +1,10 @@
+deepctl-core>=0.1.0
+click>=8.0.0
+rich>=13.0.0
+pydantic>=2.0.0
+httpx>=0.24.0
+aiohttp>=3.9.0
+
+[dev]
+pytest>=7.0.0
+pytest-asyncio>=0.21.0

deepctl_cmd_debug_browser-0.1.0/src/deepctl_cmd_debug_browser.egg-info/top_level.txt

@@ -0,0 +1 @@
+deepctl_cmd_debug_browser