Skip to content

Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI

23.5 KB
Raw Blame
import os
import subprocess
import click

from .backend import Pod
from . import DeploymentConfig, execute_serve
from .backend.event import EventStatus
from .environment import EKS_CLUSTER_NAME, AWS_REGION, AWS_PROFILE, KUBECONFIG_PATH, BUILDER_NAMESPACE, ALB_SHARED_GROUP_NAME


@click.group()
def cli():
    """Jockey - Kubernetes deployment management tool."""
    pass


@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace to list pods from')
def list_instances(namespace):
    """List all running pod instances in the namespace."""
    try:
        pods = Pod.filter(namespace=namespace)

        if not pods:
            click.echo(f"No running instances found in namespace '{namespace}'.")
            return

        click.echo(f"Found {len(pods)} running instance(s) in namespace '{namespace}':\n")

        for pod in pods:
            status = "●" if pod.ready else "○"
            phase = pod.phase or "Unknown"
            node = pod.node_name or "N/A"

            click.echo(f"{status} {pod.name}")
            click.echo(f"  Phase: {phase}")
            click.echo(f"  Node: {node}")
            click.echo(f"  Restarts: {pod.restart_count}")
            if pod.pod_ip:
                click.echo(f"  IP: {pod.pod_ip}")
            click.echo()

    except Exception as e:
        click.echo(f"Error listing instances: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('pod_name')
def stop_pod(namespace, pod_name):
    """Stop (delete) a pod by name."""
    try:
        click.echo(f"🛑 Stopping pod '{pod_name}' in namespace '{namespace}'...")

        success = Pod.delete_by_name(name=pod_name, namespace=namespace)

        if success:
            click.echo(f"✅ Pod '{pod_name}' deleted successfully!")
        else:
            click.echo(
                f"❌ Failed to delete pod '{pod_name}' - it may not exist or you may not have permission."
            )
            raise click.Abort()

    except Exception as e:
        click.echo(f"❌ Error stopping pod: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('deployment_name')
def stop_deployment(namespace, deployment_name):
    """Stop (delete) a deployment by name."""
    try:
        from .backend.models.deployment import Deployment

        click.echo(f"🛑 Stopping deployment '{deployment_name}' in namespace '{namespace}'...")

        # Check if deployment exists first
        deployment = Deployment.get(name=deployment_name, namespace=namespace)
        if not deployment:
            click.echo(f"❌ Deployment '{deployment_name}' not found in namespace '{namespace}'.")
            raise click.Abort()

        # Delete the deployment
        success = Deployment.delete_by_name(name=deployment_name, namespace=namespace)

        if success:
            click.echo(f"✅ Deployment '{deployment_name}' deleted successfully!")
            click.echo("💡 All pods managed by this deployment will be terminated.")
        else:
            click.echo(f"❌ Failed to delete deployment '{deployment_name}'.")
            raise click.Abort()

    except Exception as e:
        click.echo(f"❌ Error stopping deployment: {e}", err=True)
        raise click.Abort()


@cli.command()
def setup_kubeconfig():
    """Generate kubeconfig for EKS cluster using AWS CLI."""
    try:
        # Assert required environment variables are set
        if not EKS_CLUSTER_NAME:
            raise ValueError("EKS_CLUSTER_NAME")
        if not AWS_REGION:
            raise ValueError("AWS_REGION")

        # Ensure config directory exists
        os.makedirs(os.path.dirname(KUBECONFIG_PATH), exist_ok=True)

        click.echo(f"Generating kubeconfig for cluster: {EKS_CLUSTER_NAME}")
        click.echo(f"Region: {AWS_REGION}")

        # Run aws eks update-kubeconfig command
        cmd = [
            'aws',
            'eks',
            'update-kubeconfig',
            '--region',
            AWS_REGION,
            '--name',
            EKS_CLUSTER_NAME,
            '--kubeconfig',
            KUBECONFIG_PATH,
        ]

        if AWS_PROFILE:
            cmd.extend(['--profile', AWS_PROFILE])

        result = subprocess.run(cmd, capture_output=True, text=True)

        if result.returncode == 0:
            click.echo("✅ Kubeconfig generated successfully!")
            click.echo(f"Config saved to: {KUBECONFIG_PATH}")
        else:
            click.echo("❌ Failed to generate kubeconfig:")
            click.echo(result.stderr)
            raise click.Abort()

    except ValueError as e:
        click.echo(f"❌ Missing required environment variable: {e}")
        click.echo("Please ensure EKS_CLUSTER_NAME and AWS_REGION are set in your .env file")
        raise click.Abort()
    except FileNotFoundError:
        click.echo("❌ awscli not found. Please install it first.")
        raise click.Abort()
    except Exception as e:
        click.echo(f"❌ Error generating kubeconfig: {e}")
        raise click.Abort()


@cli.command()
def setup_builder():
    """Setup builder namespace and create AWS credentials secret from local AWS CLI."""
    try:
        from .environment import KUBECONFIG_PATH, AWS_PROFILE
        
        click.echo("🔧 Setting up builder namespace and AWS credentials...")
        
        # Create builder namespace
        cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'create', 'namespace', BUILDER_NAMESPACE]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode == 0:
            click.echo("✅ Builder namespace created")
        elif "already exists" in result.stderr:
            click.echo("✅ Builder namespace already exists")
        else:
            click.echo(f"❌ Failed to create builder namespace: {result.stderr}")
            raise click.Abort()
        
        # Get AWS credentials from local AWS CLI
        aws_cmd = ['aws', 'configure', 'get', 'aws_access_key_id']
        if AWS_PROFILE:
            aws_cmd.extend(['--profile', AWS_PROFILE])
        
        access_key_result = subprocess.run(aws_cmd, capture_output=True, text=True)
        if access_key_result.returncode != 0:
            click.echo("❌ Failed to get AWS access key from local AWS CLI")
            click.echo("   Please ensure AWS CLI is configured with 'aws configure'")
            raise click.Abort()
        
        aws_cmd = ['aws', 'configure', 'get', 'aws_secret_access_key']
        if AWS_PROFILE:
            aws_cmd.extend(['--profile', AWS_PROFILE])
        
        secret_key_result = subprocess.run(aws_cmd, capture_output=True, text=True)
        if secret_key_result.returncode != 0:
            click.echo("❌ Failed to get AWS secret key from local AWS CLI")
            click.echo("   Please ensure AWS CLI is configured with 'aws configure'")
            raise click.Abort()
        
        access_key = access_key_result.stdout.strip()
        secret_key = secret_key_result.stdout.strip()
        
        if not access_key or not secret_key:
            click.echo("❌ AWS credentials are empty")
            click.echo("   Please ensure AWS CLI is configured with 'aws configure'")
            raise click.Abort()
        
        # Delete existing secret if it exists
        delete_cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'delete', 'secret', 'aws-credentials', '-n', BUILDER_NAMESPACE]
        subprocess.run(delete_cmd, capture_output=True, text=True)  # Ignore errors
        
        # Create aws-credentials secret in builder namespace
        secret_cmd = [
            'kubectl', '--kubeconfig', KUBECONFIG_PATH, 'create', 'secret', 'generic', 'aws-credentials',
            f'--from-literal=access-key={access_key}',
            f'--from-literal=secret-key={secret_key}',
            '--namespace', BUILDER_NAMESPACE
        ]
        
        result = subprocess.run(secret_cmd, capture_output=True, text=True)
        if result.returncode == 0:
            click.echo("✅ AWS credentials secret created in builder namespace")
        else:
            click.echo(f"❌ Failed to create AWS credentials secret: {result.stderr}")
            raise click.Abort()
        
        click.echo("🎉 Builder namespace setup complete!")
        click.echo("   • Builder namespace created")
        click.echo("   • AWS credentials secret created from local AWS CLI")
        
    except FileNotFoundError:
        click.echo("❌ kubectl or aws CLI not found. Please install them first.")
        raise click.Abort()
    except Exception as e:
        click.echo(f"❌ Error setting up builder namespace: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--name', help='Name for the test image (defaults to configured repository)')
@click.option('--namespace', default='default', help='Kubernetes namespace for build context')
@click.option('--template', default='test', help='Docker template to use (test or python-agent)')
def test_build(name, namespace, template):
    """Test image build and push with streaming progress."""
    try:
        from .backend.models.image import Image
        from .backend.event import EventStatus

        from jockey.environment import IMAGE_REGISTRY, IMAGE_REPOSITORY

        # Use default repository if no name provided
        image_name = name or IMAGE_REPOSITORY

        click.echo("🔨 Testing image build and push:")
        click.echo(f"   Name: {image_name}")
        click.echo(f"   Namespace: {namespace}")
        click.echo(f"   Template: {template}")
        click.echo("   Builder: Kaniko in-cluster")
        click.echo(f"   Registry: {IMAGE_REGISTRY}")
        click.echo()

        image = Image(
            name=image_name,
            tag='test',
            namespace=namespace,
            dockerfile_template=template,
        )

        click.echo("🔨 Building and pushing image...")
        for event in image.build():
            if event.status == EventStatus.STARTED:
                click.echo(f"   Started building {image.image_name}")
            elif event.status == EventStatus.PROGRESS and event.message:
                # Show build steps but filter out excessive output
                message = event.message.strip()
                if message and not message.startswith(' ---'):
                    click.echo(f"   {message}")
            elif event.status == EventStatus.COMPLETED:
                click.echo(f"✅ Build completed: {image.image_name}")
                click.echo(f"✅ Image pushed to registry: {image.url}")
                click.echo("💡 Image available for deployments in cluster!")
                return
            elif event.status == EventStatus.ERROR:
                click.echo(f"❌ Build failed: {event.message}")
                raise click.Abort()

    except Exception as e:
        click.echo(f"❌ Error during build test: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--namespace', default=BUILDER_NAMESPACE, help=f'Kubernetes namespace (defaults to {BUILDER_NAMESPACE})')
@click.option('--follow', '-f', is_flag=True, help='Follow/stream logs in real-time')
def logs_builder(namespace, follow):
    """Show logs from the most recent builder pod."""
    try:
        # Search only in the builder namespace (or specified namespace)
        pods = Pod.filter(namespace=namespace, label_selector="job-name")
        builder_pods = [p for p in pods if p.name.startswith('builder-')]

        if not builder_pods:
            click.echo(f"No builder pods found in namespace '{namespace}'.")
            return

        # Sort by creation time (most recent first)
        builder_pods.sort(key=lambda p: p.creation_timestamp or "", reverse=True)
        latest_builder = builder_pods[0]

        click.echo(f"📋 Showing logs for builder pod: {latest_builder.name}")
        click.echo(f"   Namespace: {latest_builder.namespace}")
        click.echo(f"   Phase: {latest_builder.phase}")
        click.echo(f"   Created: {latest_builder.creation_timestamp}")
        click.echo()

        # Use kubectl to follow logs
        import subprocess
        from .environment import KUBECONFIG_PATH

        cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'logs', latest_builder.name, '-n', latest_builder.namespace]

        if follow:
            cmd.append('--follow')

        # Stream logs directly to terminal
        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)

        try:
            for line in process.stdout:
                click.echo(line.rstrip())
        except KeyboardInterrupt:
            process.terminate()
            click.echo("\n🛑 Log streaming stopped.")

        process.wait()

    except Exception as e:
        click.echo(f"❌ Error getting builder logs: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--name', help='Name for the test application (defaults to configured repository)')
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.option('--template', default='test', help='Docker template to use (test, simple-api, or python-agent)')
def deploy_test(name, namespace, template):
    """Deploy a minimal test application with health checks."""
    from jockey.environment import IMAGE_REGISTRY, IMAGE_REPOSITORY

    # Use default repository if no name provided
    click.echo(f"🚀 Starting test deployment: {name or IMAGE_REPOSITORY}")
    click.echo(f"   Namespace: {namespace}")
    click.echo(f"   Template: {template}")
    click.echo(f"   Registry: {IMAGE_REGISTRY}")
    click.echo()

    # Create deployment config without repository
    config = DeploymentConfig(
        namespace=namespace,
        tag='test',
        dockerfile_template=template,
        ports=[8080],  # Simple API runs on port 8080
    )

    # Deploy with progress events and capture the return value
    generator = execute_serve(config)
    deployment = None

    try:
        for event in generator:
            if hasattr(event, 'event_type'):
                if event.event_type == 'build':
                    if event.status == EventStatus.STARTED:
                        click.echo("🔨 Building Docker image...")
                    elif event.status == EventStatus.PROGRESS and event.message:
                        click.echo(f"   {event.message.strip()}")
                    elif event.status == EventStatus.COMPLETED:
                        click.echo(f"✅ Build completed: {name or IMAGE_REPOSITORY}:test")
                    elif event.status == EventStatus.ERROR:
                        click.echo(f"❌ Build failed: {event.message}")
                        raise click.Abort()

                elif event.event_type == 'push':
                    if event.status == EventStatus.STARTED:
                        click.echo("📤 Pushing to registry...")
                    elif event.status == EventStatus.PROGRESS and event.message:
                        # Only show important push messages
                        if 'digest:' in event.message or 'Pushed' in event.message:
                            click.echo(f"   {event.message}")
                    elif event.status == EventStatus.COMPLETED:
                        click.echo(f"✅ Push completed: {event.image_url}")
                    elif event.status == EventStatus.ERROR:
                        click.echo(f"❌ Push failed: {event.message}")
                        raise click.Abort()

                elif event.event_type == 'deployment':
                    if event.status == EventStatus.STARTED:
                        click.echo("🚀 Deploying to Kubernetes...")
                    elif event.status == EventStatus.PROGRESS:
                        click.echo(f"   {event.message}")
                    elif event.status == EventStatus.COMPLETED:
                        click.echo(f"✅ Deployment ready: {event.message}")
                    elif event.status == EventStatus.ERROR:
                        click.echo(f"❌ Deployment failed: {event.message}")
                        raise click.Abort()
    except StopIteration as e:
        # Capture the return value from the generator
        deployment = e.value

    if deployment:
        click.echo("\n🎉 Test deployment successful!")
        click.echo(f"   Name: {deployment.name}")
        click.echo(f"   Image: {deployment.image_url}")
        click.echo(f"   Namespace: {deployment.namespace}")
        click.echo("\n💡 Use 'jockey list-instances' to check status")
    else:
        click.echo("⚠️  Deployment completed but no final deployment object returned")


@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace to search')
def list_alb_ingresses(namespace):
    """List all ingresses using the shared ALB."""
    try:
        from .backend.models.service import Ingress
        
        click.echo(f"🔍 Searching for ingresses using shared ALB: {ALB_SHARED_GROUP_NAME}")
        click.echo(f"   Namespace: {namespace}")
        click.echo()
        
        ingresses = Ingress.filter(namespace=namespace)
        shared_alb_ingresses = []
        
        for ingress in ingresses:
            annotations = ingress.data.metadata.annotations or {}
            group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
            if group_name == ALB_SHARED_GROUP_NAME:
                shared_alb_ingresses.append(ingress)
        
        if not shared_alb_ingresses:
            click.echo(f"No ingresses found using shared ALB group: {ALB_SHARED_GROUP_NAME}")
            return
        
        click.echo(f"Found {len(shared_alb_ingresses)} ingress(es) using shared ALB:")
        click.echo()
        
        for ingress in shared_alb_ingresses:
            annotations = ingress.data.metadata.annotations or {}
            hostname = ingress.hostname or "N/A"
            alb_hostname = ingress.load_balancer_hostname or "Pending"
            tags = annotations.get('alb.ingress.kubernetes.io/tags', 'N/A')
            
            click.echo(f"📋 {ingress.name}")
            click.echo(f"   Hostname: {hostname}")
            click.echo(f"   ALB Hostname: {alb_hostname}")
            click.echo(f"   Tags: {tags}")
            click.echo(f"   Namespace: {ingress.namespace}")
            click.echo()
            
    except Exception as e:
        click.echo(f"❌ Error listing ALB ingresses: {e}", err=True)
        raise click.Abort()


@cli.command()
def alb_status():
    """Check the status of the shared ALB configuration."""
    try:
        from .backend.models.service import Ingress
        
        click.echo(f"🔍 Checking shared ALB status: {ALB_SHARED_GROUP_NAME}")
        click.echo()
        
        # Get all ingresses across all namespaces
        all_ingresses = []
        namespaces = ['default', 'kube-system', 'agentops-deploy']  # Common namespaces
        
        for namespace in namespaces:
            try:
                ingresses = Ingress.filter(namespace=namespace)
                all_ingresses.extend(ingresses)
            except:
                continue  # Skip if namespace doesn't exist or no access
        
        shared_alb_ingresses = []
        for ingress in all_ingresses:
            annotations = ingress.data.metadata.annotations or {}
            group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
            if group_name == ALB_SHARED_GROUP_NAME:
                shared_alb_ingresses.append(ingress)
        
        if not shared_alb_ingresses:
            click.echo(f"⚠️  No ingresses found using shared ALB group: {ALB_SHARED_GROUP_NAME}")
            click.echo("   This means the shared ALB is not yet provisioned.")
            return
        
        # Check ALB status
        alb_hostnames = set()
        ready_count = 0
        
        for ingress in shared_alb_ingresses:
            alb_hostname = ingress.load_balancer_hostname
            if alb_hostname:
                alb_hostnames.add(alb_hostname)
                ready_count += 1
        
        click.echo(f"✅ Shared ALB Status:")
        click.echo(f"   Group Name: {ALB_SHARED_GROUP_NAME}")
        click.echo(f"   Total Ingresses: {len(shared_alb_ingresses)}")
        click.echo(f"   Ready Ingresses: {ready_count}")
        click.echo(f"   ALB Hostnames: {len(alb_hostnames)}")
        
        if alb_hostnames:
            click.echo("   ALB Endpoints:")
            for hostname in alb_hostnames:
                click.echo(f"     - {hostname}")
        
        # Show ingresses by namespace
        namespace_counts = {}
        for ingress in shared_alb_ingresses:
            ns = ingress.namespace
            namespace_counts[ns] = namespace_counts.get(ns, 0) + 1
        
        click.echo("   Ingresses by namespace:")
        for ns, count in namespace_counts.items():
            click.echo(f"     - {ns}: {count}")
            
    except Exception as e:
        click.echo(f"❌ Error checking ALB status: {e}", err=True)
        raise click.Abort()


@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('hostname')
def validate_alb_routing(namespace, hostname):
    """Validate that ALB routing is configured correctly for a hostname."""
    try:
        from .backend.models.service import Ingress
        
        click.echo(f"🔍 Validating ALB routing for hostname: {hostname}")
        click.echo(f"   Namespace: {namespace}")
        click.echo(f"   Shared ALB Group: {ALB_SHARED_GROUP_NAME}")
        click.echo()
        
        ingresses = Ingress.filter(namespace=namespace)
        matching_ingresses = []
        
        for ingress in ingresses:
            if ingress.hostname == hostname:
                matching_ingresses.append(ingress)
        
        if not matching_ingresses:
            click.echo(f"❌ No ingresses found for hostname: {hostname}")
            return
        
        ingress = matching_ingresses[0]
        annotations = ingress.data.metadata.annotations or {}
        
        # Check ALB configuration
        group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
        scheme = annotations.get('alb.ingress.kubernetes.io/scheme', '')
        target_type = annotations.get('alb.ingress.kubernetes.io/target-type', '')
        tags = annotations.get('alb.ingress.kubernetes.io/tags', '')
        
        click.echo(f"✅ Ingress Configuration:")
        click.echo(f"   Name: {ingress.name}")
        click.echo(f"   Hostname: {ingress.hostname}")
        click.echo(f"   ALB Group: {group_name}")
        click.echo(f"   Scheme: {scheme}")
        click.echo(f"   Target Type: {target_type}")
        click.echo(f"   Tags: {tags}")
        click.echo(f"   ALB Hostname: {ingress.load_balancer_hostname or 'Pending'}")
        
        # Validation checks
        issues = []
        if group_name != ALB_SHARED_GROUP_NAME:
            issues.append(f"Group name mismatch: expected {ALB_SHARED_GROUP_NAME}, got {group_name}")
        if scheme != 'internet-facing':
            issues.append(f"Scheme should be 'internet-facing', got '{scheme}'")
        if target_type != 'ip':
            issues.append(f"Target type should be 'ip', got '{target_type}'")
        if not tags:
            issues.append("No ALB tags configured")
        
        if issues:
            click.echo()
            click.echo("⚠️  Configuration Issues:")
            for issue in issues:
                click.echo(f"   - {issue}")
        else:
            click.echo()
            click.echo("✅ All validations passed!")
            
    except Exception as e:
        click.echo(f"❌ Error validating ALB routing: {e}", err=True)
        raise click.Abort()


if __name__ == "__main__":
    cli()