pingera-cli 0.1.0__py3-none-any.whl

pingera_cli/formatters/synthetic_formatter.py

@@ -0,0 +1,350 @@
+"""
+Synthetic/Browser check result formatter
+"""
+
+from typing import Dict, Any, List
+from .base_formatter import BaseFormatter
+
+
+class SyntheticFormatter(BaseFormatter):
+    """Formatter for synthetic/browser check results"""
+
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Check if this is synthetic metadata"""
+        return 'execution_time' in metadata and 'pages' in metadata
+
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format synthetic check metadata"""
+        info = "\n[bold cyan]Synthetic Check Results:[/bold cyan]"
+
+        # Execution time
+        if 'execution_time' in metadata:
+            info += f"\n• Total Execution Time: [yellow]{metadata['execution_time']}ms[/yellow]"
+
+        # Test Summary
+        if 'test_summary' in metadata:
+            info += self._format_test_summary(metadata['test_summary'])
+
+        # Test Results
+        if 'test_results' in metadata:
+            info += self._format_test_results(metadata['test_results'])
+
+        # Logs
+        if 'logs' in metadata and metadata['logs']:
+            info += self._format_logs(metadata['logs'])
+
+        # Page Performance
+        if 'pages' in metadata and metadata['pages']:
+            info += self._format_page_performance(metadata['pages'][0])
+
+        return info
+
+    def _format_test_summary(self, summary: Dict[str, Any]) -> str:
+        """Format test summary"""
+        total = summary.get('total', 0)
+        passed = summary.get('passed', 0)
+        failed = summary.get('failed', 0)
+        return f"\n• Tests: [green]{passed} passed[/green], [red]{failed} failed[/red], [white]{total} total[/white]"
+
+    def _format_test_results(self, test_results: List[Dict[str, Any]]) -> str:
+        """Format test results"""
+        info = "\n\n[bold cyan]Test Results:[/bold cyan]"
+
+        for test in test_results:
+            status_color = "green" if test.get('status') == 'passed' else "red"
+            status_icon = "✅" if test.get('status') == 'passed' else "❌"
+            info += f"\n• {test.get('name', 'Unnamed Test')}: [{status_color}]{status_icon} {test.get('status', 'unknown')}[/{status_color}]"
+
+            if test.get('duration'):
+                info += f" ([yellow]{test['duration']}ms[/yellow])"
+            if test.get('error'):
+                info += f"\n  [red]Error: {test['error']}[/red]"
+
+            # Browser Screenshots/Videos
+            if 'browser_metadata' in test:
+                info += self._format_browser_metadata(test['browser_metadata'])
+
+        return info
+
+    def _format_browser_metadata(self, browser_meta: Dict[str, Any]) -> str:
+        """Format browser metadata (screenshots, videos)"""
+        info = ""
+
+        if browser_meta.get('screenshots'):
+            info += f"\n• Screenshots: [blue]{len(browser_meta['screenshots'])} available[/blue]"
+            screenshot_limit = None if self.verbose else 3
+            for screenshot in browser_meta['screenshots'][:screenshot_limit]:
+                name = screenshot.get('name', 'screenshot')
+                # Add download link if available
+                if 'url' in screenshot:
+                    info += f"\n  - [dim]{name}[/dim] - [blue]{screenshot['url']}[/blue]"
+                elif 'download_url' in screenshot:
+                    info += f"\n  - [dim]{name}[/dim] - [blue]{screenshot['download_url']}[/blue]"
+                else:
+                    info += f"\n  - [dim]{name}[/dim]"
+            if not self.verbose and len(browser_meta['screenshots']) > 3:
+                info += f"\n  - [dim]... and {len(browser_meta['screenshots']) - 3} more (use --verbose to see all)[/dim]"
+
+        if browser_meta.get('videos'):
+            info += f"\n• Videos: [blue]{len(browser_meta['videos'])} available[/blue]"
+            if self.verbose:
+                for video in browser_meta['videos']:
+                    name = video.get('name', 'video')
+                    if 'url' in video:
+                        info += f"\n  - [dim]{name}[/dim] - [blue]{video['url']}[/blue]"
+                    elif 'download_url' in video:
+                        info += f"\n  - [dim]{name}[/dim] - [blue]{video['download_url']}[/blue]"
+                    else:
+                        info += f"\n  - [dim]{name}[/dim]"
+
+        return info
+
+    def _format_logs(self, logs: List[Dict[str, Any]]) -> str:
+        """Format execution logs"""
+        info = "\n\n[bold cyan]Execution Logs:[/bold cyan]"
+        log_limit = None if self.verbose else 5
+
+        for i, log in enumerate(logs[:log_limit]):
+            level = log.get('level', 'info')
+            level_color = {"error": "red", "warn": "yellow", "info": "blue", "log": "white"}.get(level, "white")
+            timestamp = log.get('timestamp', 'Unknown time')
+            message = log.get('message', 'No message')
+            info += f"\n• [{level_color}]{level.upper()}[/{level_color}] [{timestamp}]: {message}"
+
+        if not self.verbose and len(logs) > 5:
+            info += f"\n• [dim]... and {len(logs) - 5} more logs (use --verbose to see all)[/dim]"
+
+        return info
+
+    def _format_page_performance(self, page: Dict[str, Any]) -> str:
+        """Format page performance data"""
+        info = "\n\n[bold cyan]Page Performance:[/bold cyan]"
+
+        if 'duration' in page:
+            info += f"\n• Page Load Duration: [yellow]{page['duration']:.2f}ms[/yellow]"
+
+        # Web Vitals
+        if 'webVitals' in page:
+            info += self._format_web_vitals(page['webVitals'])
+
+        # Network requests
+        if 'network' in page:
+            info += self._format_network_requests(page['network'])
+
+        # Document request details
+        if 'documentRequest' in page:
+            info += self._format_document_request(page['documentRequest'])
+
+        return info
+
+    def _format_web_vitals(self, vitals: Dict[str, Any]) -> str:
+        """Format Web Vitals data"""
+        info = "\n• Web Vitals:"
+        if 'FCP' in vitals:
+            info += f"\n  - First Contentful Paint: [yellow]{vitals['FCP']}ms[/yellow]"
+        if 'LCP' in vitals:
+            info += f"\n  - Largest Contentful Paint: [yellow]{vitals['LCP']}ms[/yellow]"
+        if 'TTFB' in vitals:
+            info += f"\n  - Time to First Byte: [yellow]{vitals['TTFB']}ms[/yellow]"
+        if self.verbose and 'CLS' in vitals:
+            info += f"\n  - Cumulative Layout Shift: [yellow]{vitals['CLS']}[/yellow]"
+        if self.verbose and 'FID' in vitals:
+            info += f"\n  - First Input Delay: [yellow]{vitals['FID']}ms[/yellow]"
+        return info
+
+    def _format_network_requests(self, network: List[Dict[str, Any]]) -> str:
+        """Format network requests"""
+        info = f"\n• Network Requests: [white]{len(network)} total[/white]"
+
+        # Summarize by resource type
+        resource_types = {}
+        for req in network:
+            res_type = req.get('resourceType', 'unknown')
+            resource_types[res_type] = resource_types.get(res_type, 0) + 1
+
+        for res_type, count in resource_types.items():
+            info += f"\n  - {res_type}: [blue]{count}[/blue]"
+
+        # Show detailed network requests in verbose mode
+        if self.verbose:
+            info += self._format_detailed_network_requests(network)
+
+        return info
+
+    def _format_detailed_network_requests(self, network: List[Dict[str, Any]]) -> str:
+        """Format detailed network requests (verbose mode)"""
+        info = "\n\n[bold cyan]Detailed Network Requests:[/bold cyan]"
+
+        # In verbose mode, show ALL requests, not just first 20
+        limit = len(network) if self.verbose else 20
+
+        for i, req in enumerate(network[:limit]):
+            url = req.get('url', 'Unknown URL')
+            method = req.get('method', 'GET')
+
+            # Extract status from response field with better logic
+            status = self._extract_status(req)
+            size = self._extract_size(req)
+            duration = self._extract_duration(req)
+            res_type = req.get('resourceType', 'unknown')
+
+            # Color code status
+            status_display = self._format_status_code(status)
+            size_display = self._format_size(size)
+            duration_display = self._format_duration(duration)
+
+            info += f"\n• [{method}] {status_display} [{res_type}] {size_display} {duration_display}"
+            info += self._format_url_with_breaks(url)
+
+        # Only show truncation message if NOT in verbose mode
+        if not self.verbose and len(network) > 20:
+            info += f"\n• [dim]... and {len(network) - 20} more requests (use --verbose to see all)[/dim]"
+
+        return info
+
+    def _extract_status(self, req: Dict[str, Any]) -> Any:
+        """Extract status code from request with improved logic"""
+        # Try multiple possible locations for status code
+        if 'response' in req and req['response'] and isinstance(req['response'], dict):
+            response = req['response']
+            if 'status' in response:
+                return response['status']
+            if 'statusCode' in response:
+                return response['statusCode']
+
+        # Try direct status field
+        if 'status' in req:
+            return req['status']
+        if 'statusCode' in req:
+            return req['statusCode']
+
+        # Try nested in other common locations
+        if 'networkResponse' in req and req['networkResponse']:
+            net_resp = req['networkResponse']
+            if 'status' in net_resp:
+                return net_resp['status']
+
+        # For failed requests, they might not have a response
+        if req.get('failed') or req.get('errorText'):
+            return 'Failed'
+
+        return 'Unknown'
+
+    def _extract_size(self, req: Dict[str, Any]) -> int:
+        """Extract size from request with improved logic"""
+        # Try multiple possible locations for size data
+        if 'response' in req and req['response'] and isinstance(req['response'], dict):
+            response_data = req['response']
+
+            # Try different size fields in order of preference
+            for size_field in ['encodedDataLength', 'transferSize', 'decodedBodyLength', 'contentLength']:
+                if size_field in response_data and response_data[size_field] is not None:
+                    return int(response_data[size_field])
+
+        # Try direct size fields
+        for size_field in ['encodedDataLength', 'transferSize', 'size', 'contentLength']:
+            if size_field in req and req[size_field] is not None:
+                return int(req[size_field])
+
+        return 0
+
+    def _extract_duration(self, req: Dict[str, Any]) -> float:
+        """Extract duration from request with improved logic"""
+        # Try direct duration field first
+        if 'duration' in req and req['duration'] is not None and req['duration'] > 0:
+            return float(req['duration'])
+
+        # Calculate from timing if available
+        if 'timing' in req and req['timing']:
+            timing = req['timing']
+            if 'responseEnd' in timing and 'requestStart' in timing:
+                duration = timing['responseEnd'] - timing['requestStart']
+                if duration > 0:
+                    return duration
+
+        # Try other common duration fields
+        for duration_field in ['responseTime', 'loadTime', 'totalTime']:
+            if duration_field in req and req[duration_field] is not None:
+                return float(req[duration_field])
+
+        return 0
+
+    def _format_status_code(self, status: Any) -> str:
+        """Format status code with appropriate color"""
+        if isinstance(status, int):
+            if 200 <= status < 300:
+                return f"[green]{status}[/green]"
+            elif 400 <= status < 500:
+                return f"[yellow]{status}[/yellow]"
+            elif status >= 500:
+                return f"[red]{status}[/red]"
+            else:
+                return f"[white]{status}[/white]"
+        elif str(status).lower() == 'failed':
+            return f"[red]Failed[/red]"
+        else:
+            return f"[white]{status}[/white]"
+
+    def _format_url_with_breaks(self, url: str) -> str:
+        """Format URL with line breaks for readability"""
+        if len(url) <= 90:
+            return f"\n  [dim]{url}[/dim]"
+
+        # Find a good break point
+        break_points = ['/', '?', '&', '=']
+        best_break = 80
+        for bp in break_points:
+            pos = url.rfind(bp, 50, 85)
+            if pos > 0:
+                best_break = pos + 1
+                break
+
+        return f"\n  [dim]{url[:best_break]}[/dim]\n  [dim]{url[best_break:]}[/dim]"
+
+    def _format_document_request(self, doc_req: Dict[str, Any]) -> str:
+        """Format main document request details"""
+        info = "\n\n[bold cyan]Main Document Request:[/bold cyan]"
+
+        if 'url' in doc_req:
+            info += f"\n• URL: [white]{doc_req['url']}[/white]"
+        if 'method' in doc_req:
+            info += f"\n• Method: [white]{doc_req['method']}[/white]"
+        if 'statusCode' in doc_req:
+            status_code = doc_req['statusCode']
+            if 200 <= status_code < 300:
+                info += f"\n• Status: [green]{status_code}[/green]"
+            elif 400 <= status_code < 500:
+                info += f"\n• Status: [yellow]{status_code}[/yellow]"
+            else:
+                info += f"\n• Status: [red]{status_code}[/red]"
+
+        if self.verbose and 'responseHeaders' in doc_req:
+            info += self._format_response_headers(doc_req['responseHeaders'])
+
+        return info
+
+    def _format_response_headers(self, headers: Dict[str, Any]) -> str:
+        """Format response headers"""
+        info = "\n• Response Headers:"
+
+        if self.verbose:
+            # In verbose mode, show ALL headers
+            for header, value in headers.items():
+                info += f"\n  - {header}: [dim]{value}[/dim]"
+        else:
+            # In non-verbose mode, show important headers only
+            important_headers = [
+                'content-type', 'content-length', 'server', 'cache-control',
+                'x-frame-options', 'strict-transport-security'
+            ]
+
+            for header in important_headers:
+                if header in headers:
+                    value = self._truncate_text(headers[header])
+                    info += f"\n  - {header}: [dim]{value}[/dim]"
+
+            other_count = len(headers) - len([h for h in important_headers if h in headers])
+            if other_count > 0:
+                info += f"\n  - [dim]... and {other_count} more headers[/dim]"
+
+        return info

pingera_cli/formatters/web_formatter.py

@@ -0,0 +1,78 @@
+
+"""
+Web check result formatter
+"""
+
+from typing import Dict, Any
+from .base_formatter import BaseFormatter
+
+
+class WebFormatter(BaseFormatter):
+    """Formatter for web check results"""
+    
+    def can_format(self, metadata: Dict[str, Any]) -> bool:
+        """Check if this is web metadata"""
+        return 'headers' in metadata or 'status_code' in metadata
+    
+    def format(self, metadata: Dict[str, Any]) -> str:
+        """Format web check metadata"""
+        info = "\n[bold cyan]Web Check Results:[/bold cyan]"
+        
+        # HTTP Response
+        if 'status_code' in metadata:
+            code = metadata['status_code']
+            if 200 <= code < 300:
+                info += f"\n• Status Code: [green]{code}[/green]"
+            elif 400 <= code < 500:
+                info += f"\n• Status Code: [yellow]{code}[/yellow]"
+            else:
+                info += f"\n• Status Code: [red]{code}[/red]"
+        
+        # IP and Location
+        if 'ip_address' in metadata:
+            info += f"\n• IP Address: [white]{metadata['ip_address']}[/white]"
+        if 'region' in metadata:
+            info += f"\n• Region: [white]{metadata['region']}[/white]"
+        if 'provider' in metadata:
+            info += f"\n• Provider: [white]{metadata['provider']}[/white]"
+        
+        # SSL Certificate Info
+        if 'ssl_cert_expiration' in metadata:
+            info += f"\n• SSL Expires: [white]{metadata['ssl_cert_expiration']}[/white]"
+            if 'ssl_cert_expiration_seconds' in metadata:
+                days = metadata['ssl_cert_expiration_seconds'] // 86400
+                color = "green" if days > 30 else "yellow" if days > 7 else "red"
+                info += f" ([{color}]{days} days remaining[/{color}])"
+        
+        # Response Headers
+        if 'headers' in metadata:
+            info += self._format_headers(metadata['headers'])
+        
+        return info
+    
+    def _format_headers(self, headers: Dict[str, Any]) -> str:
+        """Format response headers"""
+        info = "\n\n[bold cyan]Response Headers:[/bold cyan]"
+        
+        if self.verbose:
+            # In verbose mode, show ALL headers
+            for header, value in headers.items():
+                info += f"\n• {header.title()}: [dim]{value}[/dim]"
+        else:
+            # In non-verbose mode, show important headers only
+            important_headers = [
+                'content-type', 'content-length', 'server', 'cache-control', 
+                'x-frame-options', 'strict-transport-security', 'x-content-type-options'
+            ]
+            
+            for header in important_headers:
+                if header in headers:
+                    value = self._truncate_text(headers[header])
+                    info += f"\n• {header.title()}: [dim]{value}[/dim]"
+            
+            # Count other headers
+            other_count = len(headers) - len([h for h in important_headers if h in headers])
+            if other_count > 0:
+                info += f"\n• [dim]... and {other_count} more headers (use --verbose to see all)[/dim]"
+        
+        return info

pingera_cli/main.py

@@ -0,0 +1,214 @@
+"""
+Main CLI application entry point using typer framework
+"""
+
+import os
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from . import __version__
+from .commands.base import BaseCommand
+from .commands.auth import auth_cmd
+from .commands.checks import app as checks_app
+from .utils.console import console, error_console
+from .utils.config import get_config
+
+# Initialize the main Typer app
+app = typer.Typer(
+    name="pngr",
+    help="🚀 pngr - a nice CLI for Pingera platform\n\n🌐 Web application: https://app.pingera.ru\n💡 Get the API key in the app first to use the CLI",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+# Initialize base command handler
+base_cmd = BaseCommand()
+
+# Add subcommands
+app.add_typer(auth_cmd.app, name="auth")
+app.add_typer(checks_app, name="checks")
+
+
+@app.command("version")
+def version():
+    """
+    Show pngr version information
+    """
+    version_text = Text(f"PingeraCLI v{__version__}", style="bold blue")
+
+    panel = Panel(
+        version_text,
+        title="🔍 Version Info",
+        border_style="blue",
+        padding=(1, 2),
+    )
+
+    console.print(panel)
+
+    # Additional system info
+    console.print(f"[dim]Python: {sys.version.split()[0]}[/dim]")
+    console.print(f"[dim]Platform: {sys.platform}[/dim]")
+
+
+@app.command("info")
+def info():
+    """
+    Show information about pngr and Pingera SDK
+    """
+    try:
+        from pingera import ApiClient
+        sdk_version = getattr(ApiClient, '__version__', 'Unknown')
+        sdk_status = "[green]✓ Installed[/green]"
+    except ImportError:
+        sdk_version = "Not installed"
+        sdk_status = "[red]✗ Not found[/red]"
+
+    info_content = f"""
+[bold blue]pngr[/bold blue] v{__version__}
+A beautiful CLI tool for Pingera Platform
+
+[bold]🌐 Pingera Platform:[/bold]
+• Web Dashboard: [link=https://app.pingera.ru]https://app.pingera.ru[/link]
+• Documentation: [link=https://docs.pingera.ru]https://docs.pingera.ru[/link]
+• Monitor uptime, performance, and availability of your services
+
+[bold]📦 Dependencies:[/bold]
+• Pingera SDK: {sdk_status} ({sdk_version})
+• Typer: [green]✓ Installed[/green]
+• Rich: [green]✓ Installed[/green]
+
+[bold]🔧 Configuration:[/bold]
+• Config file: {get_config().get('config_path', 'Not found')}
+• API Key: {'[green]✓ Set[/green]' if os.getenv('PINGERA_API_KEY') else '[yellow]⚠ Not set[/yellow]'}
+
+[bold]📚 Usage:[/bold]
+Run [cyan]pngr --help[/cyan] to see available commands.
+    """
+
+    panel = Panel(
+        info_content.strip(),
+        title="ℹ️  System Information",
+        border_style="cyan",
+        padding=(1, 2),
+    )
+
+    console.print(panel)
+
+
+@app.command("config")
+def config(
+    show: bool = typer.Option(False, "--show", "-s", help="Show current configuration"),
+    set_api_key: Optional[str] = typer.Option(None, "--api-key", help="Set Pingera API key"),
+    set_output_format: Optional[str] = typer.Option(None, "--output-format", help="Set output format (table, json, yaml)"),
+):
+    """
+    Manage pngr configuration
+    """
+    from .utils.config import set_output_format as save_output_format
+    
+    if set_api_key:
+        # In a real implementation, this would save to a config file
+        console.print(f"[yellow]Note:[/yellow] Set environment variable PINGERA_API_KEY={set_api_key}")
+        console.print("[green]✓[/green] API key configuration noted. Please set as environment variable.")
+        return
+
+    if set_output_format:
+        if set_output_format in ['table', 'json', 'yaml']:
+            if save_output_format(set_output_format):
+                console.print(f"[green]✓[/green] Output format set to: {set_output_format}")
+            else:
+                console.print(f"[red]✗[/red] Failed to save output format")
+        else:
+            console.print(f"[red]✗[/red] Invalid output format. Use: table, json, or yaml")
+        return
+
+    if show:
+        config_data = get_config()
+
+        config_content = f"""
+[bold]🔧 Current Configuration:[/bold]
+
+[bold]API Settings:[/bold]
+• API Key: {'[green]✓ Set[/green]' if os.getenv('PINGERA_API_KEY') else '[red]✗ Not set[/red]'}
+• Base URL: {config_data.get('base_url', 'https://api.pingera.ru')}
+
+[bold]CLI Settings:[/bold]
+• Output Format: {config_data.get('output_format', 'table')}
+• Verbose Mode: {config_data.get('verbose', False)}
+• Color Output: {config_data.get('color', True)}
+        """
+
+        panel = Panel(
+            config_content.strip(),
+            title="⚙️  Configuration",
+            border_style="green",
+            padding=(1, 2),
+        )
+
+        console.print(panel)
+    else:
+        console.print("[yellow]Use --show to display current configuration, --api-key to set API key, or --output-format to set output format[/yellow]")
+
+
+
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", "-V", help="Show version and exit"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose output"),
+    output: str = typer.Option("table", "--output", "-o", help="Output format: table, json, yaml"),
+):
+    """
+    🚀 pngr - a nice CLI for Pingera platform
+    
+    Monitor your services, APIs, and websites with powerful uptime monitoring.
+    Manage checks, view results, and get insights right from your terminal.
+    
+    🌐 Web Dashboard: https://app.pingera.ru
+    📚 Documentation: https://docs.pingera.ru
+    💡 Create an account at https://app.pingera.ru to get started with monitoring and get an API key
+
+    Built with ❤️ using Typer and Rich for the best CLI experience.
+    """
+    if version:
+        console.print(f"[bold blue]PingeraCLI[/bold blue] v{__version__}")
+        raise typer.Exit()
+
+    if verbose:
+        console.print("[dim]Verbose mode enabled[/dim]")
+    
+    # Store current output format in config temporarily for subcommands
+    from .utils.config import set_output_format as save_output_format
+    save_output_format(output)
+
+
+def cli_entry_point():
+    """
+    Entry point for the CLI application
+    """
+    try:
+        app()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]⚠ Operation cancelled by user[/yellow]")
+        sys.exit(1)
+    except Exception as e:
+        error_console.print(f"[red]Unexpected error:[/red] {str(e)}")
+        sys.exit(1)
+
+
+def main():
+    """
+    Main function for module execution
+    """
+    cli_entry_point()
+
+
+if __name__ == "__main__":
+    main()

pingera_cli/utils/__init__.py

@@ -0,0 +1,8 @@
+"""
+Utilities module for PingeraCLI
+"""
+
+from .console import console, error_console
+from .config import get_config, save_config
+
+__all__ = ["console", "error_console", "get_config", "save_config"]