pingera-cli 0.1.13__tar.gz → 0.1.15__tar.gz

{pingera_cli-0.1.13/pingera_cli.egg-info → pingera_cli-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingera-cli
-Version: 0.1.13
+Version: 0.1.15
 Summary: A beautiful Python CLI tool built with typer and rich, distributed via pip and based on Pingera SDK
 Home-page: https://github.com/pingera/pingera-cli
 Author: PingeraCLI Team
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: pingera-sdk>=1.0.11
+Requires-Dist: pingera-sdk>=1.0.13
 Requires-Dist: click>=8.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"

{pingera_cli-0.1.13 → pingera_cli-0.1.15}/pingera_cli/__init__.py

@@ -2,7 +2,7 @@
 Pingera CLI - A beautiful CLI tool for Pingera Platform
 """
 
-__version__ = "0.1.13"
+__version__ = "0.1.15"
 __author__ = "Pingera Team"
 __description__ = "A beautiful Python CLI tool built with typer and rich, distributed via pip and based on Pingera SDK"
 

{pingera_cli-0.1.13 → pingera_cli-0.1.15}/pingera_cli/commands/checks.py

@@ -14,6 +14,9 @@ from rich.prompt import Confirm
 from .base import BaseCommand
 from ..utils.config import get_api_key
 
+# Supported check types
+SUPPORTED_CHECK_TYPES = ["web", "api", "tcp", "ssl", "dns", "icmp", "portscan", "synthetic", "multistep"]
+
 
 class ChecksCommand(BaseCommand):
     """
@@ -412,7 +415,7 @@ class ChecksCommand(BaseCommand):
             self.display_error(str(e))
             raise typer.Exit(1)
 
-    def create_check(self, name: str, check_type: str, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: int = 300, timeout: int = 30, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None):
+    def create_check(self, name: str, check_type: str, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: int = 300, timeout: int = 30, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, regions: Optional[str] = None):
         """Create a new monitoring check"""
         try:
             import json
@@ -525,7 +528,14 @@ class ChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
 
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+
+            # Parse parameters JSON if provided (this takes precedence over --regions)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -583,7 +593,7 @@ class ChecksCommand(BaseCommand):
             self.display_error(f"Failed to create check: {str(e)}")
             raise typer.Exit(1)
 
-    def update_check(self, check_id: str, name: Optional[str] = None, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: Optional[int] = None, timeout: Optional[int] = None, active: Optional[bool] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None):
+    def update_check(self, check_id: str, name: Optional[str] = None, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: Optional[int] = None, timeout: Optional[int] = None, active: Optional[bool] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, regions: Optional[str] = None):
         """Update an existing check"""
         try:
             import json
@@ -629,7 +639,14 @@ class ChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
 
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+
+            # Parse parameters JSON if provided (this takes precedence over --regions)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -749,7 +766,7 @@ class ChecksCommand(BaseCommand):
             # If result_id was specified, we're fetching a single result - display it with full formatting
             if result_id and len(response.results) == 1:
                 result = response.results[0]
-                
+
                 if self.output_format in ['json', 'yaml']:
                     result_dict = {
                         "id": str(result.id) if hasattr(result, 'id') and result.id else None,
@@ -901,10 +918,8 @@ class ChecksCommand(BaseCommand):
 
                 # Provide helpful hints based on context
                 hints = []
-                if check_id:
-                    hints.append(f"Use 'pngr checks result {check_id} <result-id>' for detailed result info")
-                else:
-                    hints.append("Use 'pngr checks results --result-id <result-id>' for detailed result info")
+                hints.append("Use 'pngr checks result <result-id>' for detailed result info")
+                if not check_id:
                     hints.append("Use 'pngr checks list' to see all available checks and their IDs")
                     hints.append("Filter results: --type <type>, --status <status>, --region <region>")
 
@@ -935,16 +950,19 @@ class ChecksCommand(BaseCommand):
             self.display_error(f"Failed to get result details: {str(e)}")
             raise typer.Exit(1)
 
-    def get_check_result_detailed(self, check_id: str, result_id: str, verbose: bool = False):
-        """Get detailed information for a specific check result using check_id and result_id"""
+    def get_check_result_detailed(self, result_id: str, verbose: bool = False):
+        """Get detailed information for a specific check result using result_id"""
         try:
-            checks_api = self.get_client()
+            unified_api = self.get_unified_results_client()
 
-            # Use the actual SDK method
-            result = checks_api.v1_checks_check_id_results_check_result_id_get(
-                check_id=check_id,
-                check_result_id=result_id
-            )
+            # Use the unified results API with result_id filter
+            response = unified_api.v1_checks_all_results_get(result_id=result_id)
+
+            if not hasattr(response, 'results') or not response.results or len(response.results) == 0:
+                self.display_error(f"Result {result_id} not found")
+                raise typer.Exit(1)
+
+            result = response.results[0]
 
             if self.output_format in ['json', 'yaml']:
                 # Full result data for JSON/YAML
@@ -979,7 +997,7 @@ class ChecksCommand(BaseCommand):
                 response_time_display = f"{result.response_time}ms"
         else:
             response_time_display = 'N/A'
-        
+
         basic_info = f"""[bold cyan]Basic Information:[/bold cyan]
 • Result ID: [white]{result.id}[/white]
 • Check ID: [white]{result.check_id}[/white]
@@ -1058,6 +1076,7 @@ class ChecksCommand(BaseCommand):
                     region_dict = {
                         "id": str(region.id) if hasattr(region, 'id') and region.id else None,
                         "display_name": region.display_name if hasattr(region, 'display_name') and region.display_name else None,
+                        "aliases": region.aliases if hasattr(region, 'aliases') and region.aliases else None,
                         "available_check_types": region.available_check_types if hasattr(region, 'available_check_types') and region.available_check_types else None
                     }
                     regions_data.append(region_dict)
@@ -1073,6 +1092,7 @@ class ChecksCommand(BaseCommand):
                 table = Table(title=table_title)
                 table.add_column("Region ID", style="cyan", min_width=15)
                 table.add_column("Display Name", style="green", min_width=25)
+                table.add_column("Aliases", style="yellow", min_width=20)
                 table.add_column("Available Check Types", style="white")
 
                 for region in response.regions:
@@ -1080,6 +1100,14 @@ class ChecksCommand(BaseCommand):
                     region_id = str(region.id) if hasattr(region, 'id') and region.id else "-"
                     display_name = region.display_name if hasattr(region, 'display_name') and region.display_name else "-"
 
+                    # Handle aliases
+                    aliases_display = "-"
+                    if hasattr(region, 'aliases') and region.aliases:
+                        if isinstance(region.aliases, list):
+                            aliases_display = ", ".join(region.aliases)
+                        else:
+                            aliases_display = str(region.aliases)
+
                     # Handle available check types
                     available_types = "-"
                     if hasattr(region, 'available_check_types') and region.available_check_types:
@@ -1091,6 +1119,7 @@ class ChecksCommand(BaseCommand):
                     table.add_row(
                         region_id,
                         display_name,
+                        aliases_display,
                         available_types
                     )
 
@@ -1169,15 +1198,15 @@ def list_checks(
 ):
     """List monitoring checks with advanced filtering options"""
     from ..utils.config import get_output_format
-    
+
     # Validate name length
     if name and len(name) > 100:
         typer.echo("Error: Name filter cannot exceed 100 characters", err=True)
         raise typer.Exit(1)
 
     # Validate check type
-    if check_type and check_type not in ["web", "api", "ssl", "tcp", "icmp", "dns", "synthetic", "multistep"]:
-        typer.echo("Error: Invalid check type. Must be one of: web, api, ssl, tcp, icmp, dns, synthetic, multistep", err=True)
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
         raise typer.Exit(1)
 
     # Validate status values if provided
@@ -1214,7 +1243,8 @@ def create_check(
     timeout: int = typer.Option(30, "--timeout", help="Timeout in seconds"),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"regions\": [\"US\", \"EU\"]}')"),
     pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
-    from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration")
+    from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration"),
+    regions: Optional[str] = typer.Option(None, "--regions", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1')"),
 ):
     """Create a new monitoring check. Can be created from command line options or from a JSON/YAML file.
 
@@ -1236,8 +1266,13 @@ def create_check(
         typer.echo("Error: --name is required when not using --from-file", err=True)
         raise typer.Exit(1)
 
+    # Validate check type
+    if check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.create_check(name, check_type, url, host, port, interval, timeout, parameters, pw_script_file, from_file)
+    checks_cmd.create_check(name, check_type, url, host, port, interval, timeout, parameters, pw_script_file, from_file, regions)
 
 
 @app.command("update")
@@ -1251,12 +1286,13 @@ def update_check(
     timeout: Optional[int] = typer.Option(None, "--timeout", help="New timeout in seconds"),
     active: bool = typer.Option(None, "--active/--inactive", help="Enable or disable the check"),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"pw_script\": \"...\", \"regions\": [\"US\", \"EU\"]}')"),
-    pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks")
+    pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
+    regions: Optional[str] = typer.Option(None, "--regions", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1')"),
 ):
     """Update an existing check. Use --parameters to provide complex parameters like Playwright scripts, regions, etc."""
     from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.update_check(check_id, name, url, host, port, interval, timeout, active, parameters, pw_script_file)
+    checks_cmd.update_check(check_id, name, url, host, port, interval, timeout, active, parameters, pw_script_file, regions)
 
 
 @app.command("delete")
@@ -1284,20 +1320,25 @@ def get_results(
 ):
     """Get check results with advanced filtering. If no check_id is provided, returns unified results across all checks. Use --result-id to fetch a specific result."""
     from ..utils.config import get_output_format
+
+    # Validate check type
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.get_check_results(check_id, from_date, to_date, page, page_size, status, check_type, region, result_id)
 
 
 @app.command("result")
 def get_result(
-    check_id: str = typer.Argument(..., help="Check ID"),
     result_id: str = typer.Argument(..., help="Result ID to retrieve detailed information for"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show full detailed information including network requests"),
 ):
     """Get detailed information for a specific check result"""
     from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.get_check_result_detailed(check_id, result_id, verbose)
+    checks_cmd.get_check_result_detailed(result_id, verbose)
 
 
 @app.command("list-regions")
@@ -1306,6 +1347,12 @@ def list_regions(
 ):
     """List available regions for monitoring checks"""
     from ..utils.config import get_output_format
+
+    # Validate check type
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.list_regions(check_type)
 

{pingera_cli-0.1.13 → pingera_cli-0.1.15}/pingera_cli/commands/on_demand_checks.py

@@ -13,14 +13,18 @@ from rich.panel import Panel
 from .base import BaseCommand
 from ..utils.config import get_api_key
 
+# Supported check types for on-demand execution
+SUPPORTED_CHECK_TYPES = ["web", "api", "tcp", "ssl", "dns", "icmp", "portscan", "synthetic", "multistep"]
+
 
 class OnDemandChecksCommand(BaseCommand):
     """
     Commands for managing on-demand monitoring checks
     """
     
-    def __init__(self, output_format: Optional[str] = None):
+    def __init__(self, output_format: Optional[str] = None, verbose: bool = False):
         super().__init__(output_format)
+        self.verbose = verbose
     
     def _parse_check_file(self, file_path: str) -> dict:
         """Parse check configuration from JSON or YAML file (local or URL)"""
@@ -63,7 +67,7 @@ class OnDemandChecksCommand(BaseCommand):
             self.display_error(f"Failed to initialize client: {str(e)}")
             raise typer.Exit(1)
 
-    def execute_custom_check(self, url: Optional[str] = None, check_type: str = "web", host: Optional[str] = None, port: Optional[int] = None, timeout: int = 30, name: str = "On-demand check", parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, wait_for_result: bool = True):
+    def execute_custom_check(self, url: Optional[str] = None, check_type: str = "web", host: Optional[str] = None, port: Optional[int] = None, timeout: Optional[int] = None, name: str = "On-demand check", regions: Optional[str] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, wait_for_result: bool = True, ports: Optional[str] = None):
         """Execute custom on-demand check"""
         try:
             import json
@@ -85,10 +89,15 @@ class OnDemandChecksCommand(BaseCommand):
                 # Command line options take precedence over file data
                 check_data = {
                     "name": filtered_file_data.get("name", name),
-                    "type": filtered_file_data.get("type", check_type),
-                    "timeout": filtered_file_data.get("timeout", timeout)
+                    "type": filtered_file_data.get("type", check_type)
                 }
                 
+                # Handle timeout - only set if explicitly provided or in file
+                if timeout is not None:
+                    check_data["timeout"] = timeout
+                elif "timeout" in filtered_file_data:
+                    check_data["timeout"] = filtered_file_data["timeout"]
+                
                 # Override with command line values if provided
                 if name != "On-demand check":  # Only override if name was explicitly provided
                     check_data["name"] = name
@@ -141,9 +150,12 @@ class OnDemandChecksCommand(BaseCommand):
                 # Build check data normally
                 check_data = {
                     "name": name,
-                    "type": check_type,
-                    "timeout": timeout
+                    "type": check_type
                 }
+                
+                # Only set timeout if explicitly provided by user
+                if timeout is not None:
+                    check_data["timeout"] = timeout
             
             # Add URL if provided (required for web, api, ssl checks)
             if url is not None:
@@ -177,7 +189,18 @@ class OnDemandChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
             
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+            
+            # Handle ports parameter - add to params_dict if provided and not in parameters
+            if ports is not None and parameters is None:
+                params_dict["ports"] = ports
+            
+            # Parse parameters JSON if provided (this takes precedence over --regions and --ports)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -194,11 +217,17 @@ class OnDemandChecksCommand(BaseCommand):
             
             # Validation based on check type - use the actual type from check_data
             actual_check_type = check_data.get("type", check_type)
+            
+            # Validate check type is supported
+            if actual_check_type not in SUPPORTED_CHECK_TYPES:
+                self.display_error(f"Invalid check type: {actual_check_type}. Supported types: {', '.join(SUPPORTED_CHECK_TYPES)}")
+                raise typer.Exit(1)
+            
             if actual_check_type in ['web', 'api'] and not url:
                 self.display_error(f"URL is required for {actual_check_type} checks")
                 raise typer.Exit(1)
             
-            if actual_check_type in ['tcp'] and not host:
+            if actual_check_type in ['tcp', 'portscan', 'dns', 'icmp'] and not host:
                 self.display_error(f"Host is required for {actual_check_type} checks")
                 raise typer.Exit(1)
             
@@ -446,15 +475,17 @@ class OnDemandChecksCommand(BaseCommand):
                 }
                 self.output_data(job_data)
             else:
-                # Rich formatted detailed view
-                self._display_detailed_job_status(job_status, job_id)
+                # Rich formatted detailed view - fetch and display with results
+                self._fetch_and_display_job_result(job_id, job_status, verbose=self.verbose)
             
         except Exception as e:
             self.display_error(f"Failed to get job status: {str(e)}")
             raise typer.Exit(1)
 
-    def _fetch_and_display_job_result(self, job_id: str, job_status):
+    def _fetch_and_display_job_result(self, job_id: str, job_status, verbose: bool = False):
         """Fetch detailed results from the new results endpoint and display them"""
+        import time
+        
         try:
             # Extract result_id(s) from job response
             result_ids = []
@@ -463,14 +494,56 @@ class OnDemandChecksCommand(BaseCommand):
             if hasattr(job_status, 'result') and job_status.result:
                 result = job_status.result
                 
+                # Debug: Print the raw result to see what we're getting (only in verbose mode)
+                if verbose and self.output_format not in ['json', 'yaml']:
+                    import json
+                    self.console.print(f"[dim]DEBUG: Raw result from job status:[/dim]")
+                    self.console.print(f"[dim]{json.dumps(result, indent=2, default=str)}[/dim]")
+                
                 # Check if this is a multi-region result
                 if isinstance(result, dict):
                     if 'regional_summary' in result and result['regional_summary']:
                         # Multi-region execution
                         is_multi_region = True
-                        for regional_result in result['regional_summary']:
+                        regional_summary = result['regional_summary']
+                        
+                        # Debug: Show what we found (only in verbose mode)
+                        if verbose and self.output_format not in ['json', 'yaml']:
+                            self.console.print(f"[dim]DEBUG: Found {len(regional_summary)} regions in regional_summary[/dim]")
+                        
+                        for regional_result in regional_summary:
                             if 'result_id' in regional_result:
                                 result_ids.append(regional_result['result_id'])
+                        
+                        # Check if we might be missing results (race condition detection)
+                        total_regions = result.get('total_regions', len(regional_summary))
+                        completed_regions = result.get('completed_regions', len(regional_summary))
+                        
+                        if verbose and self.output_format not in ['json', 'yaml']:
+                            self.console.print(f"[dim]DEBUG: total_regions={total_regions}, completed_regions={completed_regions}, found result_ids={len(result_ids)}[/dim]")
+                        
+                        # If we're missing results, wait a bit and refetch
+                        if len(result_ids) < total_regions:
+                            if self.output_format not in ['json', 'yaml']:
+                                self.console.print(f"[yellow]⚠ Race condition detected: {len(result_ids)}/{total_regions} results ready. Waiting 2s and retrying...[/yellow]")
+                            time.sleep(2)
+                            
+                            # Refetch job status
+                            checks_api = self.get_client()
+                            job_status = checks_api.v1_checks_jobs_job_id_get(job_id=job_id)
+                            
+                            # Re-extract result_ids
+                            result_ids = []
+                            if hasattr(job_status, 'result') and job_status.result:
+                                result = job_status.result
+                                if isinstance(result, dict) and 'regional_summary' in result:
+                                    for regional_result in result['regional_summary']:
+                                        if 'result_id' in regional_result:
+                                            result_ids.append(regional_result['result_id'])
+                                    
+                                    if verbose and self.output_format not in ['json', 'yaml']:
+                                        self.console.print(f"[dim]DEBUG: After retry, found {len(result_ids)} result_ids[/dim]")
+                    
                     elif 'result_id' in result:
                         # Single-region execution
                         result_ids.append(result['result_id'])
@@ -487,14 +560,14 @@ class OnDemandChecksCommand(BaseCommand):
                 raise typer.Exit(1)
             
             from pingera import ApiClient, Configuration
-            from pingera.api import ChecksApi
+            from pingera.api import ChecksUnifiedResultsApi
             from ..utils.config import get_config
             
             configuration = Configuration()
             configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
             api_client = ApiClient(configuration)
-            checks_api = ChecksApi(api_client)
+            checks_api = ChecksUnifiedResultsApi(api_client)
             
             # Fetch detailed results for each result_id
             if is_multi_region:
@@ -547,13 +620,15 @@ class OnDemandChecksCommand(BaseCommand):
         self.console.print(f"\n[bold cyan]Multi-Region Execution Result[/bold cyan]")
         self.console.print(f"• Job ID: [white]{job_id}[/white]")
         self.console.print(f"• Status: [{status_color}]{status_emoji} {job_status.status}[/{status_color}]")
-        self.console.print(f"• Regions: [white]{len(result_ids)}[/white]")
         
         # Extract and display aggregated statistics
         if hasattr(job_status, 'result') and isinstance(job_status.result, dict):
             result = job_status.result
             regional_summary = result.get('regional_summary', [])
             
+            # Display region count from actual regional_summary
+            self.console.print(f"• Regions: [white]{len(regional_summary)}[/white]")
+            
             if regional_summary:
                 # Calculate aggregated statistics
                 response_times = []
@@ -616,19 +691,68 @@ class OnDemandChecksCommand(BaseCommand):
     
     def _display_detailed_result_with_job_info(self, job_status, job_id: str, detailed_result):
         """Display detailed result information combined with job info"""
-        # Use the existing detailed result display logic from checks.py
-        # For now, use the job status display and note about detailed results
-        self._display_detailed_job_status(job_status, job_id)
+        from rich.panel import Panel
+        from ..formatters.registry import FormatterRegistry
+        
+        # Determine status color and emoji
+        status_emoji = "✅" if hasattr(detailed_result, 'status') and detailed_result.status == 'ok' else "❌"
+        status_color = "green" if hasattr(detailed_result, 'status') and detailed_result.status == 'ok' else "red"
         
-        # Additional result details if available
+        # Basic information
+        basic_info = f"""[bold cyan]Basic Information:[/bold cyan]
+• Result ID: [white]{detailed_result.id if hasattr(detailed_result, 'id') else 'Unknown'}[/white]
+• Check ID: [white]{detailed_result.check_id if hasattr(detailed_result, 'check_id') and detailed_result.check_id else 'None'}[/white]
+• Status: [{status_color}]{status_emoji} {detailed_result.status if hasattr(detailed_result, 'status') else 'Unknown'}[/{status_color}]
+• Timestamp: [white]{detailed_result.created_at.strftime('%Y-%m-%d %H:%M:%S UTC') if hasattr(detailed_result, 'created_at') and detailed_result.created_at else 'Unknown'}[/white]"""
+        
+        if hasattr(detailed_result, 'response_time') and detailed_result.response_time:
+            basic_info += f"\n• Response Time: [yellow]{detailed_result.response_time}ms[/yellow]"
+        
+        # Server information
+        if hasattr(detailed_result, 'check_server') and detailed_result.check_server:
+            server = detailed_result.check_server
+            server_info = f"""• Check Server: [white]{server.id if hasattr(server, 'id') else 'Unknown'}[/white]
+• Server IP: [white]{server.ip_address if hasattr(server, 'ip_address') else 'Unknown'}[/white]
+• Server Country: [white]{server.country if hasattr(server, 'country') else 'Unknown'}[/white]
+• Server Region: [white]{server.region if hasattr(server, 'region') else 'Unknown'}[/white]"""
+            basic_info += f"\n{server_info}"
+        
+        # Error information
+        error_info = ""
+        if hasattr(detailed_result, 'error_message') and detailed_result.error_message:
+            error_info = f"""
+[bold red]Error Information:[/bold red]
+• Error: [red]{detailed_result.error_message}[/red]"""
+        
+        # Metadata analysis using formatters
+        metadata_info = ""
         if hasattr(detailed_result, 'check_metadata') and detailed_result.check_metadata:
-            from ..formatters.registry import FormatterRegistry
-            registry = FormatterRegistry(verbose=False)
-            metadata_formatted = registry.format_metadata(detailed_result.check_metadata)
+            metadata = detailed_result.check_metadata
             
-            if metadata_formatted.strip():
-                self.console.print(f"\n[bold cyan]Detailed Result Metadata:[/bold cyan]")
-                self.console.print(metadata_formatted)
+            if isinstance(metadata, dict):
+                # Add result_id to metadata for formatters to use in truncation notice
+                metadata_with_id = metadata.copy()
+                if hasattr(detailed_result, 'id'):
+                    metadata_with_id['result_id'] = detailed_result.id
+                
+                registry = FormatterRegistry(verbose=self.verbose)
+                metadata_info = registry.format_metadata(metadata_with_id)
+        
+        # Combine all sections
+        full_info = basic_info
+        if error_info:
+            full_info += error_info
+        if metadata_info:
+            full_info += metadata_info
+        
+        panel = Panel(
+            full_info,
+            title=f"🔍 Result Details: {detailed_result.id if hasattr(detailed_result, 'id') else 'Unknown'}",
+            border_style="blue",
+            padding=(1, 2),
+        )
+        
+        self.console.print(panel)
     
     def _display_detailed_job_status(self, job_status, job_id: str):
         """Display detailed job status information in a rich format"""
@@ -806,7 +930,7 @@ class OnDemandChecksCommand(BaseCommand):
                                 time.sleep(0.5)  # Brief pause to show completion
                             
                             # Fetch and display the actual result
-                            self._fetch_and_display_job_result(job_id, job_status)
+                            self._fetch_and_display_job_result(job_id, job_status, verbose=self.verbose)
                             return
                         
                         elif job_status.status == 'running':
@@ -858,14 +982,22 @@ def get_output_format():
     return get_config().get('output_format', 'table')
 
 
+def get_verbose_mode():
+    """Get verbose mode from config"""
+    from ..utils.config import get_verbose_mode as _get_verbose_mode
+    return _get_verbose_mode()
+
+
 @run_app.command("custom")
 def run_custom_check(
     url: Optional[str] = typer.Option(None, "--url", "-u", help="URL to monitor (required for web, api, ssl checks)"),
-    check_type: str = typer.Option("web", "--type", "-t", help="Check type (web, api, tcp, ssl, synthetic, multistep)"),
-    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL checks (max 255 characters)"),
-    port: Optional[int] = typer.Option(None, "--port", help="Port number for TCP checks (1-65535)"),
-    timeout: int = typer.Option(30, "--timeout", help="Timeout in seconds"),
+    check_type: str = typer.Option("web", "--type", "-t", help=f"Check type: {', '.join(SUPPORTED_CHECK_TYPES)}"),
+    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL/portscan/DNS/ICMP checks (max 255 characters)"),
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="Port number for TCP/SSL checks (1-65535)"),
+    ports: Optional[str] = typer.Option(None, "--ports", help="Ports to scan for portscan checks (e.g., '80,443' or '1-1024'). Overridden by --parameters if both are specified."),
+    timeout: Optional[int] = typer.Option(None, "--timeout", help="Timeout in seconds (optional - backend will use defaults if not specified)"),
     name: str = typer.Option("On-demand check", "--name", "-n", help="Check name"),
+    regions: Optional[str] = typer.Option(None, "--regions", "-r", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1'). Overridden by --parameters if both are specified."),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"regions\": [\"US\", \"EU\"]}')"),
     pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
     from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration"),
@@ -883,10 +1015,13 @@ def run_custom_check(
     Parameters vary by check type:
     - web/api: --url required
     - tcp: --host required, --port optional  
-    - ssl: --url or --host required
-    - synthetic/multistep: --pw-script-file or --parameters with pw_script required"""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
-    on_demand_cmd.execute_custom_check(url, check_type, host, port, timeout, name, parameters, pw_script_file, from_file, not no_wait)
+    - ssl: --url or --host required, --port optional
+    - portscan: --host required, --ports optional
+    - synthetic/multistep: --pw-script-file or --parameters with pw_script required
+    
+    Timeout is optional - if not specified, backend will use appropriate defaults for each check type."""
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
+    on_demand_cmd.execute_custom_check(url, check_type, host, port, timeout, name, regions, parameters, pw_script_file, from_file, not no_wait, ports)
 
 
 @run_app.command("existing")
@@ -895,7 +1030,7 @@ def run_existing_check(
     no_wait: bool = typer.Option(False, "--no-wait", help="Don't wait for job completion, just queue the check and return job ID"),
 ):
     """Execute existing check on demand. By default, waits for job completion and shows result immediately (max 5 minutes). Use --no-wait to just queue the check."""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.execute_existing_check(check_id, not no_wait)
 
 
@@ -905,7 +1040,7 @@ def list_jobs(
     page_size: int = typer.Option(20, "--page-size", "-s", help="Items per page"),
 ):
     """List check jobs"""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.list_jobs(page, page_size)
 
 
@@ -914,5 +1049,5 @@ def get_job_status(
     job_id: str = typer.Argument(..., help="Job ID to get status for"),
 ):
     """Get job status and results. For multi-region executions, shows aggregated statistics and regional summary."""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.get_job_status(job_id)