clue2app-cli 0.2.7__py3-none-any.whl

clue2app_cli/__init__.py

@@ -0,0 +1,10 @@
+"""
+Clue2App CLI - A command line interface for the Clue2App platform.
+
+This package provides CLI commands for interacting with the Clue2App platform,
+including authentication, data management, and various app operations.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Clue2App CLI Team"
+__email__ = "support@clue2app.com"

clue2app_cli/agents/__init__.py

@@ -0,0 +1,9 @@
+"""
+Agents module for Clue2App CLI.
+
+Provides autonomous agents for monitoring and self-healing operations.
+"""
+
+from .ecr_healer import ECRHealerAgent
+
+__all__ = ["ECRHealerAgent"]

clue2app_cli/agents/ecr_healer.py

@@ -0,0 +1,475 @@
+"""
+ECR Healer Agent - Automatically detects and resolves ECR credential issues.
+
+This agent monitors builds for ECR authentication failures and attempts to:
+1. Detect builds that failed due to ECR token expiration
+2. Trigger ECR credential refresh
+3. Retry failed builds
+
+Usage:
+    # One-time check and heal
+    agent = ECRHealerAgent()
+    agent.run_once()
+
+    # Continuous monitoring (runs every 5 minutes)
+    agent = ECRHealerAgent(interval=300)
+    agent.run_forever()
+"""
+
+import time
+import re
+from typing import Dict, Any, List, Optional, Callable
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.live import Live
+
+from ..sdk import Clue2AppSDK
+from ..config import get_config_value
+
+
+console = Console()
+
+
+@dataclass
+class HealingAction:
+    """Represents a healing action taken by the agent."""
+    timestamp: datetime
+    app_name: str
+    project_id: str
+    action: str  # "refresh_creds", "retry_build", "skip"
+    reason: str
+    success: bool
+    error: Optional[str] = None
+
+
+@dataclass
+class AgentState:
+    """Tracks the agent's internal state."""
+    started_at: datetime = field(default_factory=datetime.now)
+    last_check: Optional[datetime] = None
+    checks_performed: int = 0
+    issues_detected: int = 0
+    issues_healed: int = 0
+    actions: List[HealingAction] = field(default_factory=list)
+
+
+class ECRHealerAgent:
+    """
+    Autonomous agent for detecting and healing ECR credential issues.
+
+    The agent monitors kpack builds for failures related to ECR authentication
+    and attempts to automatically resolve them by refreshing credentials and
+    retrying builds.
+    """
+
+    # Patterns that indicate ECR credential issues
+    ECR_ERROR_PATTERNS = [
+        r"authorization token has expired",
+        r"DENIED.*reauthenticate",
+        r"unable to fetch remote.*ecr",
+        r"ecr.*unauthorized",
+        r"ecr.*access denied",
+        r"no basic auth credentials",
+    ]
+
+    def __init__(
+        self,
+        interval: int = 300,  # Check every 5 minutes by default
+        max_retries: int = 3,
+        dry_run: bool = False,
+        on_action: Optional[Callable[[HealingAction], None]] = None,
+        verbose: bool = True,
+    ):
+        """
+        Initialize the ECR Healer Agent.
+
+        Args:
+            interval: Seconds between checks in continuous mode
+            max_retries: Maximum retry attempts per build
+            dry_run: If True, detect issues but don't take action
+            on_action: Callback function called when an action is taken
+            verbose: If True, print detailed status messages
+        """
+        self.sdk = Clue2AppSDK()
+        self.interval = interval
+        self.max_retries = max_retries
+        self.dry_run = dry_run
+        self.on_action = on_action
+        self.verbose = verbose
+        self.state = AgentState()
+        self._retry_counts: Dict[str, int] = {}  # Track retries per build
+        self._stop_requested = False
+
+    def _log(self, message: str, style: str = ""):
+        """Log a message if verbose mode is enabled."""
+        if self.verbose:
+            if style:
+                console.print(f"[{style}]{message}[/{style}]")
+            else:
+                console.print(message)
+
+    def _is_ecr_error(self, message: str) -> bool:
+        """Check if an error message indicates an ECR credential issue."""
+        if not message:
+            return False
+        message_lower = message.lower()
+        return any(
+            re.search(pattern, message_lower)
+            for pattern in self.ECR_ERROR_PATTERNS
+        )
+
+    def _get_failed_builds(self, project_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get all builds that have failed due to ECR issues."""
+        failed_builds = []
+
+        try:
+            # Get all images (builds)
+            images = self.sdk.list_images(project_id=project_id)
+
+            for image in images:
+                conditions = image.get("status", {}).get("conditions", [])
+                if not conditions:
+                    continue
+
+                condition = conditions[0]
+                status = condition.get("status")
+                reason = condition.get("reason", "")
+                message = condition.get("message", "")
+
+                # Check if it's a failed build with ECR error
+                if status == "False" and reason == "BuildFailed":
+                    if self._is_ecr_error(message):
+                        failed_builds.append({
+                            "name": image.get("metadata", {}).get("name"),
+                            "display_name": image.get("metadata", {}).get("displayName"),
+                            "uid": image.get("metadata", {}).get("uid"),
+                            "namespace": image.get("metadata", {}).get("namespace"),
+                            "message": message,
+                            "project_id": image.get("metadata", {}).get("labels", {}).get("appGroupId"),
+                        })
+
+        except Exception as e:
+            self._log(f"Error fetching builds: {e}", "red")
+
+        return failed_builds
+
+    def _refresh_ecr_credentials(self) -> bool:
+        """
+        Trigger ECR credential refresh.
+
+        This calls the coordinator API to refresh ECR authentication tokens.
+        """
+        try:
+            # Call the coordinator to refresh ECR credentials
+            response = self.sdk._make_authenticated_request(
+                "POST",
+                "/api/admin/refresh-ecr-credentials"
+            )
+
+            if response.status_code == 200:
+                self._log("✓ ECR credentials refreshed successfully", "green")
+                return True
+            elif response.status_code == 404:
+                # Endpoint might not exist yet, log and continue
+                self._log("⚠ ECR refresh endpoint not available (404)", "yellow")
+                return False
+            else:
+                self._log(f"✗ Failed to refresh ECR credentials: {response.status_code}", "red")
+                return False
+
+        except Exception as e:
+            self._log(f"✗ Error refreshing ECR credentials: {e}", "red")
+            return False
+
+    def _retry_build(self, image_name: str) -> bool:
+        """
+        Retry a failed build.
+
+        Args:
+            image_name: The name of the image to rebuild
+
+        Returns:
+            True if rebuild was triggered successfully
+        """
+        try:
+            result = self.sdk.rebuild_app(image_name)
+            if result.get("success"):
+                self._log(f"✓ Triggered rebuild for {image_name}", "green")
+                return True
+            else:
+                self._log(f"✗ Failed to trigger rebuild: {result.get('error')}", "red")
+                return False
+        except Exception as e:
+            self._log(f"✗ Error triggering rebuild for {image_name}: {e}", "red")
+            return False
+
+    def _record_action(self, action: HealingAction):
+        """Record an action and call the callback if set."""
+        self.state.actions.append(action)
+        if self.on_action:
+            self.on_action(action)
+
+    def check_and_heal(self) -> List[HealingAction]:
+        """
+        Perform one check cycle - detect ECR issues and attempt to heal them.
+
+        Returns:
+            List of actions taken during this cycle
+        """
+        self.state.checks_performed += 1
+        self.state.last_check = datetime.now()
+        actions = []
+
+        self._log(f"\n[bold]🔍 Checking for ECR credential issues...[/bold]")
+
+        # Get all projects
+        try:
+            projects = self.sdk.list_projects()
+        except Exception as e:
+            self._log(f"Error fetching projects: {e}", "red")
+            return actions
+
+        all_failed_builds = []
+
+        # Check each project for failed builds
+        for project in projects:
+            project_id = project.get("id")
+            project_name = project.get("name")
+
+            failed_builds = self._get_failed_builds(project_id)
+            for build in failed_builds:
+                build["project_name"] = project_name
+                all_failed_builds.append(build)
+
+        if not all_failed_builds:
+            self._log("✓ No ECR-related build failures detected", "green")
+            return actions
+
+        self.state.issues_detected += len(all_failed_builds)
+        self._log(f"⚠ Found {len(all_failed_builds)} build(s) with ECR credential issues", "yellow")
+
+        # Display failed builds
+        table = Table(title="Failed Builds (ECR Issues)")
+        table.add_column("App", style="cyan")
+        table.add_column("Project", style="magenta")
+        table.add_column("Error", style="red", max_width=50)
+
+        for build in all_failed_builds:
+            table.add_row(
+                build.get("display_name", build.get("name")),
+                build.get("project_name", "Unknown"),
+                build.get("message", "")[:50] + "..."
+            )
+
+        console.print(table)
+
+        if self.dry_run:
+            self._log("\n[yellow]Dry run mode - no actions taken[/yellow]")
+            for build in all_failed_builds:
+                action = HealingAction(
+                    timestamp=datetime.now(),
+                    app_name=build.get("name"),
+                    project_id=build.get("project_id"),
+                    action="skip",
+                    reason="Dry run mode",
+                    success=True,
+                )
+                actions.append(action)
+                self._record_action(action)
+            return actions
+
+        # Attempt to refresh ECR credentials
+        self._log("\n[bold]🔧 Attempting to refresh ECR credentials...[/bold]")
+        creds_refreshed = self._refresh_ecr_credentials()
+
+        if not creds_refreshed:
+            self._log("⚠ Could not refresh credentials, will still attempt rebuilds", "yellow")
+
+        # Retry failed builds
+        self._log("\n[bold]🔄 Retrying failed builds...[/bold]")
+
+        for build in all_failed_builds:
+            build_name = build.get("name")
+
+            # Check retry count
+            retry_count = self._retry_counts.get(build_name, 0)
+            if retry_count >= self.max_retries:
+                self._log(f"⏭ Skipping {build_name} - max retries ({self.max_retries}) reached", "yellow")
+                action = HealingAction(
+                    timestamp=datetime.now(),
+                    app_name=build_name,
+                    project_id=build.get("project_id"),
+                    action="skip",
+                    reason=f"Max retries ({self.max_retries}) reached",
+                    success=False,
+                )
+                actions.append(action)
+                self._record_action(action)
+                continue
+
+            # Attempt rebuild
+            success = self._retry_build(build_name)
+            self._retry_counts[build_name] = retry_count + 1
+
+            action = HealingAction(
+                timestamp=datetime.now(),
+                app_name=build_name,
+                project_id=build.get("project_id"),
+                action="retry_build",
+                reason="ECR credential expiration",
+                success=success,
+                error=None if success else "Rebuild failed",
+            )
+            actions.append(action)
+            self._record_action(action)
+
+            if success:
+                self.state.issues_healed += 1
+
+        return actions
+
+    def run_once(self) -> List[HealingAction]:
+        """
+        Run a single check and heal cycle.
+
+        Returns:
+            List of actions taken
+        """
+        self._log(Panel.fit(
+            "[bold blue]ECR Healer Agent[/bold blue]\n"
+            f"Mode: {'Dry Run' if self.dry_run else 'Active'}\n"
+            f"Max Retries: {self.max_retries}",
+            title="🤖 Agent Started"
+        ))
+
+        actions = self.check_and_heal()
+
+        self._print_summary()
+        return actions
+
+    def run_forever(self):
+        """
+        Run the agent continuously, checking at the configured interval.
+
+        Use Ctrl+C to stop.
+        """
+        self._log(Panel.fit(
+            "[bold blue]ECR Healer Agent[/bold blue]\n"
+            f"Mode: {'Dry Run' if self.dry_run else 'Active'} (Continuous)\n"
+            f"Check Interval: {self.interval}s\n"
+            f"Max Retries: {self.max_retries}",
+            title="🤖 Agent Started"
+        ))
+
+        self._stop_requested = False
+
+        try:
+            while not self._stop_requested:
+                self.check_and_heal()
+
+                self._log(f"\n💤 Next check in {self.interval} seconds... (Ctrl+C to stop)")
+
+                # Sleep in small increments to allow for quick shutdown
+                for _ in range(self.interval):
+                    if self._stop_requested:
+                        break
+                    time.sleep(1)
+
+        except KeyboardInterrupt:
+            self._log("\n\n[yellow]Agent stopped by user[/yellow]")
+        finally:
+            self._print_summary()
+
+    def stop(self):
+        """Request the agent to stop (for programmatic control)."""
+        self._stop_requested = True
+
+    def _print_summary(self):
+        """Print a summary of the agent's activities."""
+        runtime = datetime.now() - self.state.started_at
+
+        summary = Table(title="Agent Summary", show_header=False)
+        summary.add_column("Metric", style="cyan")
+        summary.add_column("Value", style="white")
+
+        summary.add_row("Runtime", str(runtime).split(".")[0])
+        summary.add_row("Checks Performed", str(self.state.checks_performed))
+        summary.add_row("Issues Detected", str(self.state.issues_detected))
+        summary.add_row("Issues Healed", str(self.state.issues_healed))
+        summary.add_row("Total Actions", str(len(self.state.actions)))
+
+        console.print("\n")
+        console.print(summary)
+
+        if self.state.actions:
+            actions_table = Table(title="Actions Taken")
+            actions_table.add_column("Time", style="dim")
+            actions_table.add_column("App", style="cyan")
+            actions_table.add_column("Action", style="magenta")
+            actions_table.add_column("Result", style="green")
+
+            for action in self.state.actions[-10:]:  # Last 10 actions
+                actions_table.add_row(
+                    action.timestamp.strftime("%H:%M:%S"),
+                    action.app_name,
+                    action.action,
+                    "✓" if action.success else "✗"
+                )
+
+            console.print(actions_table)
+
+
+def main():
+    """CLI entry point for the ECR healer agent."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="ECR Healer Agent")
+    parser.add_argument(
+        "--continuous", "-c",
+        action="store_true",
+        help="Run continuously instead of one-time check"
+    )
+    parser.add_argument(
+        "--interval", "-i",
+        type=int,
+        default=300,
+        help="Check interval in seconds (default: 300)"
+    )
+    parser.add_argument(
+        "--max-retries", "-r",
+        type=int,
+        default=3,
+        help="Maximum retry attempts per build (default: 3)"
+    )
+    parser.add_argument(
+        "--dry-run", "-n",
+        action="store_true",
+        help="Detect issues but don't take any action"
+    )
+    parser.add_argument(
+        "--quiet", "-q",
+        action="store_true",
+        help="Suppress detailed output"
+    )
+
+    args = parser.parse_args()
+
+    agent = ECRHealerAgent(
+        interval=args.interval,
+        max_retries=args.max_retries,
+        dry_run=args.dry_run,
+        verbose=not args.quiet,
+    )
+
+    if args.continuous:
+        agent.run_forever()
+    else:
+        agent.run_once()
+
+
+if __name__ == "__main__":
+    main()