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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingera-cli
-Version: 0.1.11
+Version: 0.1.13
 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.8
+Requires-Dist: pingera-sdk>=1.0.11
 Requires-Dist: click>=8.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"

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

@@ -2,7 +2,7 @@
 Pingera CLI - A beautiful CLI tool for Pingera Platform
 """
 
-__version__ = "0.1.11"
+__version__ = "0.1.13"
 __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.11 → pingera_cli-0.1.13}/pingera_cli/__main__.py

@@ -3,7 +3,6 @@
 Main module entry point for python -m pingera_cli execution
 """
 
-from .main import cli_entry_point
-
 if __name__ == "__main__":
+    from .main import cli_entry_point
     cli_entry_point()

{pingera_cli-0.1.11 → pingera_cli-0.1.13}/pingera_cli/commands/auth.py

@@ -224,8 +224,10 @@ API Key: ✗ Not set
             from pingera.exceptions import UnauthorizedException
 
             # Configure the client (same pattern as checks command)
+            from ..utils.config import get_config
+            
             configuration = Configuration()
-            configuration.host = "https://api.pingera.ru"
+            configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
 
             # Create API client

{pingera_cli-0.1.11 → pingera_cli-0.1.13}/pingera_cli/commands/check_groups.py

@@ -33,10 +33,11 @@ class CheckGroupsCommand(BaseCommand):
         try:
             from pingera import ApiClient, Configuration
             from pingera.api import CheckGroupsApi
+            from ..utils.config import get_config
 
             # Configure the client
             configuration = Configuration()
-            configuration.host = "https://api.pingera.ru"
+            configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
 
             # Create API client

{pingera_cli-0.1.11 → pingera_cli-0.1.13}/pingera_cli/commands/check_secrets.py

@@ -34,10 +34,11 @@ class CheckSecretsCommand(BaseCommand):
         try:
             from pingera import ApiClient, Configuration
             from pingera.api import CheckSecretsApi
+            from ..utils.config import get_config
 
             # Configure the client
             configuration = Configuration()
-            configuration.host = "https://api.pingera.ru"
+            configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
 
             # Create API client

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

@@ -33,10 +33,11 @@ class ChecksCommand(BaseCommand):
         try:
             from pingera import ApiClient, Configuration
             from pingera.api import ChecksApi
+            from ..utils.config import get_config
 
             # Configure the client
             configuration = Configuration()
-            configuration.host = "https://api.pingera.ru"
+            configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
 
             # Create API client
@@ -59,10 +60,11 @@ class ChecksCommand(BaseCommand):
         try:
             from pingera import ApiClient, Configuration
             from pingera.api import ChecksUnifiedResultsApi
+            from ..utils.config import get_config
 
             # Configure the client
             configuration = Configuration()
-            configuration.host = "https://api.pingera.ru"
+            configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
 
             # Create API client
@@ -85,7 +87,7 @@ class ChecksCommand(BaseCommand):
                 "page": page,
                 "page_size": page_size
             }
-            
+
             # Add optional filters
             if check_type:
                 params["type"] = check_type
@@ -148,12 +150,12 @@ class ChecksCommand(BaseCommand):
                     filters_applied.append(f"name='{name}'")
                 if group_id:
                     filters_applied.append(f"group={group_id}")
-                
+
                 if filters_applied:
                     title_parts.append(f"({', '.join(filters_applied)})")
-                
+
                 table_title = " ".join(title_parts)
-                
+
                 # Create table for default output
                 table = Table(title=table_title)
                 table.add_column("ID", style="cyan")
@@ -181,7 +183,7 @@ class ChecksCommand(BaseCommand):
                             group_display = group_name[:19] + "…"
                         else:
                             group_display = group_name
-                        
+
                         # Add color if available
                         if hasattr(check.group, 'color') and check.group.color:
                             # Use the group color for the group name display
@@ -194,8 +196,15 @@ class ChecksCommand(BaseCommand):
                     check_url = "-"
                     if hasattr(check, 'url') and check.url:
                         check_url = str(check.url)
-                    elif hasattr(check, 'host') and hasattr(check, 'port') and check.host and check.port:
-                        check_url = f"{check.host}:{check.port}"
+                    elif hasattr(check, 'host') and check.host:
+                        # For ICMP and DNS checks, show just the host
+                        # For TCP and other checks with ports, show host:port
+                        if check_type in ["icmp", "dns"]:
+                            check_url = str(check.host)
+                        elif hasattr(check, 'port') and check.port:
+                            check_url = f"{check.host}:{check.port}"
+                        else:
+                            check_url = str(check.host)
 
                     # Handle active status
                     active_status = "✅" if hasattr(check, 'active') and check.active else "❌"
@@ -227,16 +236,16 @@ class ChecksCommand(BaseCommand):
                     )
 
                 self.console.print(table)
-                
+
                 # Show result summary with filter info
                 summary_parts = [f"Found {len(response.checks)} checks"]
                 if page > 1:
                     summary_parts.append(f"on page {page}")
                 if filters_applied:
                     summary_parts.append(f"with filters: {', '.join(filters_applied)}")
-                
+
                 self.console.print(f"\n[dim]{' '.join(summary_parts)}[/dim]")
-                
+
                 # Show helpful hints for filtering
                 if not any([check_type, status, name, group_id]):
                     self.console.print(f"[dim]💡 Filter checks: --type <type>, --status <status>, --name <name>, --group-id <id>[/dim]")
@@ -293,7 +302,7 @@ class ChecksCommand(BaseCommand):
                     group_name = check.group.name if hasattr(check.group, 'name') else 'Unknown'
                     group_color = check.group.color if hasattr(check.group, 'color') and check.group.color else 'white'
                     group_desc = check.group.description if hasattr(check.group, 'description') and check.group.description else ''
-                    
+
                     group_info = f"• Group: [{group_color}]● {group_name}[/{group_color}]"
                     if group_desc:
                         group_info += f" [dim]({group_desc})[/dim]"
@@ -392,13 +401,13 @@ class ChecksCommand(BaseCommand):
     def _parse_check_file(self, file_path: str) -> dict:
         """Parse check configuration from JSON or YAML file (local or URL)"""
         from ..utils.file_utils import load_check_file, is_url
-        
+
         try:
             if is_url(file_path):
                 self.display_info(f"Downloading check configuration from: {file_path}")
-            
+
             return load_check_file(file_path)
-            
+
         except Exception as e:
             self.display_error(str(e))
             raise typer.Exit(1)
@@ -413,12 +422,12 @@ class ChecksCommand(BaseCommand):
             # If creating from file, parse file and merge with command line options
             if from_file:
                 file_data = self._parse_check_file(from_file)
-                
+
                 # Filter only SDK-recognized fields from file data
                 # This ignores marketplace-specific fields and other extensions
                 sdk_fields = ["name", "type", "url", "host", "port", "interval", "timeout", "parameters", "active", "secrets"]
                 filtered_file_data = {k: v for k, v in file_data.items() if k in sdk_fields}
-                
+
                 # Command line options take precedence over file data
                 check_data = {
                     "name": filtered_file_data.get("name", name),
@@ -426,7 +435,7 @@ class ChecksCommand(BaseCommand):
                     "interval": filtered_file_data.get("interval", interval),
                     "timeout": filtered_file_data.get("timeout", timeout)
                 }
-                
+
                 # Override with command line values if provided (but only if they were explicitly changed from defaults)
                 # We need to be more careful about when to override file values
                 # For now, just use file values and let user override with explicit CLI options
@@ -434,46 +443,46 @@ class ChecksCommand(BaseCommand):
                     check_data["interval"] = interval
                 if timeout != 30:  # Only override if timeout was explicitly provided
                     check_data["timeout"] = timeout
-                
+
                 # Handle URL from file
                 if url is None and filtered_file_data.get("url"):
                     url = filtered_file_data["url"]
                 elif url is not None:
                     # Command line URL takes precedence
                     pass
-                
+
                 # Handle host/port from file
                 if host is None and filtered_file_data.get("host"):
                     host = filtered_file_data["host"]
                 elif host is not None:
                     # Command line host takes precedence
                     pass
-                    
+
                 if port is None and filtered_file_data.get("port"):
                     port = filtered_file_data["port"]
                 elif port is not None:
                     # Command line port takes precedence
                     pass
-                
+
                 # Handle parameters from file
                 file_parameters = filtered_file_data.get("parameters")
                 if file_parameters and parameters is None:
                     # Use file parameters if no command line parameters
                     parameters = json.dumps(file_parameters) if isinstance(file_parameters, dict) else file_parameters
-                
+
                 # Handle secrets from file
                 if filtered_file_data.get("secrets"):
                     check_data["secrets"] = filtered_file_data["secrets"]
-                
+
                 # Handle pw_script_file from file (this is CLI-specific, not sent to SDK)
                 if pw_script_file is None and file_data.get("pw_script_file"):
                     pw_script_file = file_data["pw_script_file"]
-                
+
                 # Show info about ignored fields if any
                 ignored_fields = [k for k in file_data.keys() if k not in sdk_fields and k != "pw_script_file"]
                 if ignored_fields:
                     self.display_info(f"Ignoring non-SDK fields from file: {', '.join(ignored_fields)}")
-                
+
                 self.display_info(f"Creating check from file: {from_file}")
             else:
                 # Build check data normally
@@ -537,7 +546,7 @@ class ChecksCommand(BaseCommand):
                 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', 'icmp', 'dns'] and not host:
                 self.display_error(f"Host is required for {actual_check_type} checks")
                 raise typer.Exit(1)
 
@@ -696,7 +705,7 @@ class ChecksCommand(BaseCommand):
             self.display_error(f"Failed to delete check: {str(e)}")
             raise typer.Exit(1)
 
-    def get_check_results(self, check_id: Optional[str] = None, from_date: Optional[str] = None, to_date: Optional[str] = None, page: int = 1, page_size: int = 20, status: Optional[str] = None, check_type: Optional[str] = None, region: Optional[str] = None):
+    def get_check_results(self, check_id: Optional[str] = None, from_date: Optional[str] = None, to_date: Optional[str] = None, page: int = 1, page_size: int = 20, status: Optional[str] = None, check_type: Optional[str] = None, region: Optional[str] = None, result_id: Optional[str] = None):
         """Get check results using unified results API"""
         try:
             unified_api = self.get_unified_results_client()
@@ -711,6 +720,10 @@ class ChecksCommand(BaseCommand):
             if check_id:
                 params["check_id"] = check_id
 
+            # Add result_id if provided (for fetching specific result)
+            if result_id:
+                params["result_id"] = result_id
+
             # Add optional filters
             if from_date:
                 params["start_date"] = from_date
@@ -733,6 +746,36 @@ class ChecksCommand(BaseCommand):
                     self.display_info("No results found.")
                 return
 
+            # 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,
+                        "check_id": result.check_id if hasattr(result, 'check_id') else None,
+                        "check_name": result.check_name if hasattr(result, 'check_name') else None,
+                        "check_type": result.check_type if hasattr(result, 'check_type') else None,
+                        "status": result.status if hasattr(result, 'status') else None,
+                        "created_at": result.created_at if hasattr(result, 'created_at') and result.created_at else None,
+                        "response_time": result.response_time if hasattr(result, 'response_time') else None,
+                        "error_message": result.error_message if hasattr(result, 'error_message') else None,
+                        "check_server_id": result.check_server_id if hasattr(result, 'check_server_id') else None,
+                        "region": result.region if hasattr(result, 'region') else None,
+                        "result_type": result.result_type if hasattr(result, 'result_type') else None,
+                        "check_metadata": result.check_metadata if hasattr(result, 'check_metadata') else None,
+                        "check_server": {
+                            "ip_address": result.check_server.ip_address if hasattr(result, 'check_server') and result.check_server and hasattr(result.check_server, 'ip_address') else None,
+                            "country": result.check_server.country if hasattr(result, 'check_server') and result.check_server and hasattr(result.check_server, 'country') else None,
+                            "region": result.check_server.region if hasattr(result, 'check_server') and result.check_server and hasattr(result.check_server, 'region') else None
+                        } if hasattr(result, 'check_server') and result.check_server else None
+                    }
+                    self.output_data(result_dict)
+                else:
+                    # Display with full formatting using _display_detailed_result
+                    self._display_detailed_result(result, verbose=True)
+                return
+
             # Prepare data for different output formats
             if self.output_format in ['json', 'yaml']:
                 results_data = []
@@ -861,8 +904,7 @@ class ChecksCommand(BaseCommand):
                 if check_id:
                     hints.append(f"Use 'pngr checks result {check_id} <result-id>' for detailed result info")
                 else:
-                    hints.append("Use 'pngr checks result <check-id> <result-id>' for detailed result info")
-                    hints.append("For on-demand checks: use 'pngr checks jobs result <result-id>' for detailed info")
+                    hints.append("Use 'pngr checks results --result-id <result-id>' for detailed result info")
                     hints.append("Use 'pngr checks list' to see all available checks and their IDs")
                     hints.append("Filter results: --type <type>, --status <status>, --region <region>")
 
@@ -929,7 +971,15 @@ class ChecksCommand(BaseCommand):
         """Display detailed result information in a rich format"""
 
         # Basic information
-        response_time_display = f"{result.response_time}ms" if hasattr(result, 'response_time') and result.response_time else 'N/A'
+        # Handle response time display: 0 means <1ms, None/missing means N/A
+        if hasattr(result, 'response_time') and result.response_time is not None:
+            if result.response_time == 0:
+                response_time_display = "<1ms"
+            else:
+                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]
@@ -1029,7 +1079,7 @@ class ChecksCommand(BaseCommand):
                     # Extract region data using actual SDK attributes
                     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 available check types
                     available_types = "-"
                     if hasattr(region, 'available_check_types') and region.available_check_types:
@@ -1045,7 +1095,7 @@ class ChecksCommand(BaseCommand):
                     )
 
                 self.console.print(table)
-                
+
                 # Show summary
                 filter_text = f" for {check_type} checks" if check_type else ""
                 self.console.print(f"\n[dim]Found {len(response.regions)} regions{filter_text}[/dim]")
@@ -1108,32 +1158,28 @@ class ChecksCommand(BaseCommand):
 app = typer.Typer(name="checks", help="🔍 Manage monitoring checks", no_args_is_help=True)
 
 
-def get_output_format():
-    """Get output format from config"""
-    from ..utils.config import get_config
-    return get_config().get('output_format', 'table')
-
-
 @app.command("list")
 def list_checks(
     page: int = typer.Option(1, "--page", "-p", help="Page number"),
-    page_size: int = typer.Option(20, "--page-size", "-s", help="Items per page (max 100)"),
-    check_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by check type (web, api, ssl, tcp, synthetic, multistep)"),
+    page_size: int = typer.Option(20, "--page-size", "-s", help="Items per page"),
+    check_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by check type (web, api, ssl, tcp, icmp, dns, synthetic, multistep)"),
     status: Optional[str] = typer.Option(None, "--status", help="Filter by status. Multiple statuses can be separated by commas (e.g., 'ok,failed')"),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Filter by name using case-insensitive partial matching (max 100 chars)"),
     group_id: Optional[str] = typer.Option(None, "--group-id", "-g", help="Filter by group ID"),
 ):
     """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", "synthetic", "multistep"]:
-        typer.echo("Error: Invalid check type. Must be one of: web, api, ssl, tcp, synthetic, multistep", err=True)
+    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)
         raise typer.Exit(1)
-    
+
     # Validate status values if provided
     if status:
         valid_statuses = ["ok", "failed", "degraded", "timeout", "pending", "paused"]
@@ -1142,7 +1188,7 @@ def list_checks(
             if s not in valid_statuses:
                 typer.echo(f"Error: Invalid status '{s}'. Must be one of: {', '.join(valid_statuses)}", err=True)
                 raise typer.Exit(1)
-    
+
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.list_checks(page, page_size, check_type, status, name, group_id)
 
@@ -1152,6 +1198,7 @@ def get_check(
     check_id: str = typer.Argument(..., help="Check ID to retrieve"),
 ):
     """Get specific check details"""
+    from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.get_check(check_id)
 
@@ -1159,9 +1206,9 @@ def get_check(
 @app.command("create")
 def create_check(
     name: str = typer.Option("", "--name", "-n", help="Check name (required if not using --from-file)"),
-    check_type: str = typer.Option("web", "--type", "-t", help="Check type (web, api, tcp, ssl, synthetic, multistep)"),
+    check_type: str = typer.Option("web", "--type", "-t", help="Check type (web, api, tcp, ssl, icmp, dns, synthetic, multistep)"),
     url: Optional[str] = typer.Option(None, "--url", "-u", help="URL to monitor (required for web, api, ssl checks)"),
-    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL checks (max 255 characters)"),
+    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL/ICMP/DNS checks (max 255 characters)"),
     port: Optional[int] = typer.Option(None, "--port", help="Port number for TCP checks (1-65535)"),
     interval: int = typer.Option(300, "--interval", "-i", help="Check interval in seconds"),
     timeout: int = typer.Option(30, "--timeout", help="Timeout in seconds"),
@@ -1170,22 +1217,25 @@ def create_check(
     from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration")
 ):
     """Create a new monitoring check. Can be created from command line options or from a JSON/YAML file.
-    
+
     When using --from-file:
     - Command line options override file values
     - File should contain check configuration in JSON or YAML format
-    
+
     Parameters vary by check type:
     - web/api: --url required
     - tcp: --host required, --port optional
     - ssl: --url or --host required
+    - icmp: --host required (hostname or IP to ping)
+    - dns: --host required (domain name to query)
     - synthetic/multistep: --pw-script-file or --parameters with pw_script required"""
-    
+    from ..utils.config import get_output_format
+
     # Validate that we have either from_file or required parameters
     if not from_file and not name:
         typer.echo("Error: --name is required when not using --from-file", 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)
 
@@ -1204,6 +1254,7 @@ def update_check(
     pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks")
 ):
     """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)
 
@@ -1214,6 +1265,7 @@ def delete_check(
     confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation prompt"),
 ):
     """Delete a monitoring check"""
+    from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.delete_check(check_id, confirm)
 
@@ -1228,10 +1280,12 @@ def get_results(
     status: Optional[str] = typer.Option(None, "--status", help="Filter by status (ok, failed, degraded, timeout, pending)"),
     check_type: Optional[str] = typer.Option(None, "--type", help="Filter by check type (web, api, tcp, ssl, synthetic, multistep)"),
     region: Optional[str] = typer.Option(None, "--region", help="Filter by region"),
+    result_id: Optional[str] = typer.Option(None, "--result-id", "-r", help="Filter by specific result ID"),
 ):
-    """Get check results with advanced filtering. If no check_id is provided, returns unified results across all checks."""
+    """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
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.get_check_results(check_id, from_date, to_date, page, page_size, status, check_type, region)
+    checks_cmd.get_check_results(check_id, from_date, to_date, page, page_size, status, check_type, region, result_id)
 
 
 @app.command("result")
@@ -1241,6 +1295,7 @@ def get_result(
     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)
 
@@ -1250,6 +1305,7 @@ def list_regions(
     check_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter regions by check type (web, api, tcp, ssl, synthetic, multistep)"),
 ):
     """List available regions for monitoring checks"""
+    from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.list_regions(check_type)
 
@@ -1260,19 +1316,11 @@ def assign_check_to_group(
     group_id: Optional[str] = typer.Option(None, "--group-id", "-g", help="Group ID to assign check to (use 'null' to remove from group)"),
 ):
     """Assign a check to a group or remove it from a group"""
+    from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.assign_check_to_group(check_id, group_id)
 
 
-
-
-
-
-
-
-
-
-
 # Import on-demand checks functionality from separate module
 from .on_demand_checks import run_app, jobs_app
 
@@ -1282,8 +1330,12 @@ from .check_groups import app as groups_app
 # Import check secrets functionality
 from .check_secrets import app as check_secrets_app
 
-# Add the run, jobs, groups, and secrets subcommands to the main checks app
+# Import execution groups functionality
+from .execution_groups import app as execution_groups_app
+
+# Add the run, jobs, groups, secrets, and execution-groups subcommands to the main checks app
 app.add_typer(run_app, name="run")
 app.add_typer(jobs_app, name="jobs")
 app.add_typer(groups_app, name="groups")
-app.add_typer(check_secrets_app, name="secrets")
+app.add_typer(check_secrets_app, name="secrets")
+app.add_typer(execution_groups_app, name="execution-groups")