agentex-sdk 0.1.0a6__py3-none-any.whl

agentex/lib/cli/commands/secrets.py

@@ -0,0 +1,169 @@
+from pathlib import Path
+
+import questionary
+import typer
+from rich import print_json
+from rich.console import Console
+from rich.panel import Panel
+
+from agentex.lib.cli.handlers.secret_handlers import (
+    delete_secret,
+    get_kubernetes_secrets_by_type,
+    get_secret,
+    sync_secrets,
+)
+from agentex.lib.cli.utils.cli_utils import handle_questionary_cancellation
+from agentex.lib.cli.utils.kubectl_utils import (
+    check_and_switch_cluster_context,
+    validate_namespace,
+)
+from agentex.lib.sdk.config.agent_manifest import AgentManifest
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+secrets = typer.Typer()
+
+
+@secrets.command()
+def list(
+    namespace: str = typer.Option(
+        "agentex-agents", help="Kubernetes namespace to list secrets from"
+    ),
+    cluster: str | None = typer.Option(
+        None, help="Cluster context to use (defaults to current context)"
+    ),
+):
+    """List names of available secrets"""
+    logger.info(f"Listing secrets in namespace: {namespace}")
+
+    if cluster:
+        check_and_switch_cluster_context(cluster)
+        if not validate_namespace(namespace, cluster):
+            console.print(
+                f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
+            )
+            raise typer.Exit(1)
+
+    secrets_list = get_kubernetes_secrets_by_type(namespace=namespace, context=cluster)
+    print_json(data=secrets_list)
+
+
+@secrets.command()
+def get(
+    name: str = typer.Argument(..., help="Name of the secret to get"),
+    namespace: str = typer.Option(
+        "agentex-agents", help="Kubernetes namespace for the secret"
+    ),
+    cluster: str | None = typer.Option(
+        None, help="Cluster context to use (defaults to current context)"
+    ),
+):
+    """Get details about a secret"""
+    logger.info(f"Getting secret: {name} from namespace: {namespace}")
+
+    if cluster:
+        check_and_switch_cluster_context(cluster)
+        if not validate_namespace(namespace, cluster):
+            console.print(
+                f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
+            )
+            raise typer.Exit(1)
+
+    secret = get_secret(name=name, namespace=namespace, context=cluster)
+    print_json(data=secret)
+
+
+@secrets.command()
+def delete(
+    name: str = typer.Argument(..., help="Name of the secret to delete"),
+    namespace: str = typer.Option(
+        "agentex-agents", help="Kubernetes namespace for the secret"
+    ),
+    cluster: str | None = typer.Option(
+        None, help="Cluster context to use (defaults to current context)"
+    ),
+):
+    """Delete a secret"""
+    logger.info(f"Deleting secret: {name} from namespace: {namespace}")
+
+    if cluster:
+        check_and_switch_cluster_context(cluster)
+        if not validate_namespace(namespace, cluster):
+            console.print(
+                f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
+            )
+            raise typer.Exit(1)
+
+    delete_secret(name=name, namespace=namespace, context=cluster)
+
+
+@secrets.command()
+def sync(
+    manifest: str = typer.Option(..., help="Path to the manifest file"),
+    # TODO: should cluster be here or be in manifest as well?
+    cluster: str = typer.Option(..., "--cluster", help="Cluster to sync secrets to"),
+    interactive: bool = typer.Option(
+        True, "--interactive/--no-interactive", help="Enable interactive prompts"
+    ),
+    namespace: str | None = typer.Option(
+        None,
+        help="Kubernetes namespace to deploy to (required in non-interactive mode)",
+    ),
+    values: str = typer.Option(None, "--values", help="Path to the values file"),
+):
+    """Sync secrets from the cluster to the local environment"""
+    console.print(
+        Panel.fit("🚀 [bold blue]Sync Secrets[/bold blue]", border_style="blue")
+    )
+
+    manifest_path = Path(manifest)
+    if not manifest_path.exists():
+        console.print(f"[red]Error:[/red] Manifest file not found: {manifest}")
+        raise typer.Exit(1)
+
+    # In non-interactive mode, require namespace
+    if not interactive and not namespace:
+        console.print(
+            "[red]Error:[/red] --namespace is required in non-interactive mode"
+        )
+        raise typer.Exit(1)
+
+    # Get namespace if not provided (only in interactive mode)
+    if not namespace:
+        namespace = questionary.text(
+            "Enter Kubernetes namespace:", default="default"
+        ).ask()
+        namespace = handle_questionary_cancellation(namespace, "namespace input")
+
+        if not namespace:
+            console.print("Deployment cancelled")
+            raise typer.Exit(0)
+
+    if values:
+        values_path = Path(values)
+        if not values_path.exists():
+            console.print(f"[red]Error:[/red] Values file not found: {values_path}")
+            raise typer.Exit(1)
+
+    # Validate cluster and namespace
+    check_and_switch_cluster_context(cluster)
+    if not validate_namespace(namespace, cluster):
+        console.print(
+            f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
+        )
+        raise typer.Exit(1)
+
+    agent_manifest = AgentManifest.from_yaml(file_path=manifest)
+
+    # Always call sync_secrets - it will handle the case of no credentials
+    sync_secrets(
+        manifest_obj=agent_manifest,
+        cluster=cluster,
+        namespace=namespace,
+        interactive=interactive,
+        values_path=str(values) if values else None,
+    )
+
+    console.print("[green]Successfully synced secrets[/green]")

agentex/lib/cli/commands/tasks.py

@@ -0,0 +1,118 @@
+import typer
+from rich import print_json
+from rich.console import Console
+
+from agentex import Agentex
+from agentex.lib.cli.handlers.cleanup_handlers import cleanup_agent_workflows
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+tasks = typer.Typer()
+
+
+@tasks.command()
+def get(
+    task_id: str = typer.Argument(..., help="ID of the task to get"),
+):
+    """
+    Get the task with the given ID.
+    """
+    logger.info(f"Getting task: {task_id}")
+    client = Agentex()
+    task = client.tasks.retrieve(task_id=task_id)
+    print(f"Full Task {task_id}:")
+    print_json(data=task.to_dict())
+
+
+@tasks.command()
+def list():
+    """
+    List all tasks.
+    """
+    client = Agentex()
+    tasks = client.tasks.list()
+    print_json(data=[task.to_dict() for task in tasks])
+
+
+@tasks.command()
+def list_running(
+    agent_name: str = typer.Option(..., help="Name of the agent to list running tasks for"),
+):
+    """
+    List all currently running tasks for a specific agent.
+    """
+    client = Agentex()
+    all_tasks = client.tasks.list()
+    running_tasks = [task for task in all_tasks if hasattr(task, 'status') and task.status == "RUNNING"]
+    
+    if not running_tasks:
+        console.print(f"[yellow]No running tasks found for agent '{agent_name}'[/yellow]")
+        return
+        
+    console.print(f"[green]Found {len(running_tasks)} running task(s) for agent '{agent_name}':[/green]")
+    
+    # Convert to dict with proper datetime serialization
+    serializable_tasks = []
+    for task in running_tasks:
+        try:
+            # Use model_dump with mode='json' for proper datetime handling
+            if hasattr(task, 'model_dump'):
+                serializable_tasks.append(task.model_dump(mode='json'))
+            else:
+                # Fallback for non-Pydantic objects
+                serializable_tasks.append({
+                    "id": getattr(task, 'id', 'unknown'), 
+                    "status": getattr(task, 'status', 'unknown')
+                })
+        except Exception as e:
+            logger.warning(f"Failed to serialize task: {e}")
+            # Minimal fallback
+            serializable_tasks.append({
+                "id": getattr(task, 'id', 'unknown'), 
+                "status": getattr(task, 'status', 'unknown')
+            })
+    
+    print_json(data=serializable_tasks)
+
+
+@tasks.command()
+def delete(
+    task_id: str = typer.Argument(..., help="ID of the task to delete"),
+):
+    """
+    Delete the task with the given ID.
+    """
+    logger.info(f"Deleting task: {task_id}")
+    client = Agentex()
+    client.tasks.delete(task_id=task_id)
+    logger.info(f"Task deleted: {task_id}")
+
+
+@tasks.command()
+def cleanup(
+    agent_name: str = typer.Option(..., help="Name of the agent to cleanup tasks for"),
+    force: bool = typer.Option(False, help="Force cleanup using direct Temporal termination (bypasses development check)"),
+):
+    """
+    Clean up all running tasks/workflows for an agent.
+    
+    By default, uses graceful cancellation via agent RPC.
+    With --force, directly terminates workflows via Temporal client.
+    """
+    try:
+        console.print(f"[blue]Starting cleanup for agent '{agent_name}'...[/blue]")
+        
+        cleanup_agent_workflows(
+            agent_name=agent_name,
+            force=force,
+            development_only=True
+        )
+        
+        console.print(f"[green]✓ Cleanup completed for agent '{agent_name}'[/green]")
+        
+    except Exception as e:
+        console.print(f"[red]Cleanup failed: {str(e)}[/red]")
+        logger.exception("Task cleanup failed")
+        raise typer.Exit(1) from e

agentex/lib/cli/commands/uv.py

@@ -0,0 +1,133 @@
+import os
+import subprocess
+import sys
+
+import typer
+
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+
+
+uv = typer.Typer(
+    help="Wrapper for uv command with AgentEx-specific enhancements",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+sync_args = typer.Argument(None, help="Additional arguments to pass to uv sync")
+
+
+@uv.command()
+def sync(
+    ctx: typer.Context,
+    index: str | None = typer.Option(
+        None, "--index", "-i", help="UV index URL to use for sync"
+    ),
+    group: str | None = typer.Option(
+        None,
+        "--group",
+        "-g",
+        help="Include dependencies from the specified dependency group",
+    ),
+    args: list[str] = sync_args,
+):
+    """Sync dependencies with optional UV_INDEX support"""
+    args = args or []
+
+    # Check if help was requested
+    if "--help" in args or "-h" in args:
+        # Show our custom help instead of passing to uv
+        typer.echo(ctx.get_help())
+        return
+
+    if index:
+        os.environ["UV_INDEX_URL"] = index
+        logger.info(f"Using provided UV_INDEX_URL: {index}")
+
+    # Build the uv sync command
+    cmd = ["uv", "sync"]
+
+    # Add group if specified
+    if group:
+        cmd.extend(["--group", group])
+        logger.info(f"Using dependency group: {group}")
+
+    # Add any additional arguments
+    cmd.extend(args)
+
+    try:
+        result = subprocess.run(cmd, check=True)
+        sys.exit(result.returncode)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"uv sync failed with exit code {e.returncode}")
+        sys.exit(e.returncode)
+    except FileNotFoundError:
+        logger.error("uv command not found. Please install uv first.")
+        sys.exit(1)
+
+
+add_args = typer.Argument(None, help="Additional arguments to pass to uv add")
+
+
+@uv.command()
+def add(
+    ctx: typer.Context,
+    index: str | None = typer.Option(
+        None, "--index", "-i", help="UV index URL to use for add"
+    ),
+    args: list[str] = add_args,
+):
+    """Add dependencies with optional UV_INDEX support"""
+
+    args = args or []
+
+    # Check if help was requested
+    if "--help" in args or "-h" in args:
+        # Show our custom help instead of passing to uv
+        typer.echo(ctx.get_help())
+        return
+
+    if index:
+        os.environ["UV_INDEX_URL"] = index
+        logger.info(f"Using provided UV_INDEX_URL: {index}")
+
+    # Build the uv add command
+    cmd = ["uv", "add"] + (args or [])
+
+    try:
+        result = subprocess.run(cmd, check=True)
+        sys.exit(result.returncode)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"uv add failed with exit code {e.returncode}")
+        sys.exit(e.returncode)
+    except FileNotFoundError:
+        logger.error("uv command not found. Please install uv first.")
+        sys.exit(1)
+
+
+run_args = typer.Argument(None, help="Arguments to pass to uv")
+
+
+@uv.command()
+def run(
+    ctx: typer.Context,
+    args: list[str] = run_args,
+):
+    """Run any uv command with arguments"""
+    if not args:
+        # If no arguments provided, show help
+        typer.echo(ctx.get_help())
+        return
+
+    # Build the uv command
+    cmd = ["uv"] + args
+
+    try:
+        result = subprocess.run(cmd, check=True)
+        sys.exit(result.returncode)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"uv command failed with exit code {e.returncode}")
+        sys.exit(e.returncode)
+    except FileNotFoundError:
+        logger.error("uv command not found. Please install uv first.")
+        sys.exit(1)

agentex/lib/cli/handlers/agent_handlers.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from python_on_whales import DockerException, docker
+from rich.console import Console
+
+from agentex.lib.cli.handlers.run_handlers import RunError
+from agentex.lib.cli.handlers.run_handlers import run_agent as _run_agent
+from agentex.lib.sdk.config.agent_manifest import AgentManifest
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+
+class DockerBuildError(Exception):
+    """An error occurred during docker build"""
+
+
+def build_agent(
+    manifest_path: str,
+    registry_url: str,
+    repository_name: str,
+    platforms: list[str],
+    push: bool = False,
+    secret: str = None,
+    tag: str = None,
+    build_args: list[str] = None,
+) -> str:
+    """Build the agent locally and optionally push to registry
+
+    Args:
+        manifest_path: Path to the agent manifest file
+        registry_url: Registry URL for pushing the image
+        push: Whether to push the image to the registry
+        secret: Docker build secret in format 'id=secret-id,src=path-to-secret-file'
+        tag: Image tag to use (defaults to 'latest')
+        build_args: List of Docker build arguments in format 'KEY=VALUE'
+
+    Returns:
+        The image URL
+    """
+    agent_manifest = AgentManifest.from_yaml(file_path=manifest_path)
+    build_context_root = (
+        Path(manifest_path).parent / agent_manifest.build.context.root
+    ).resolve()
+
+    repository_name = repository_name or agent_manifest.agent.name
+
+    # Prepare image name
+    if registry_url:
+        image_name = f"{registry_url}/{repository_name}"
+    else:
+        image_name = repository_name
+
+    if tag:
+        image_name = f"{image_name}:{tag}"
+    else:
+        image_name = f"{image_name}:latest"
+
+    with agent_manifest.context_manager(build_context_root) as build_context:
+        logger.info(f"Building image {image_name} locally...")
+
+        # Log build context information for debugging
+        logger.info(f"Build context path: {build_context.path}")
+        logger.info(
+            f"Dockerfile path: {build_context.path / build_context.dockerfile_path}"
+        )
+
+        try:
+            # Prepare build arguments
+            docker_build_kwargs = {
+                "context_path": str(build_context.path),
+                "file": str(build_context.path / build_context.dockerfile_path),
+                "tags": [image_name],
+                "platforms": platforms,
+            }
+
+            # Add Docker build args if provided
+            if build_args:
+                docker_build_args = {}
+                for arg in build_args:
+                    if "=" in arg:
+                        key, value = arg.split("=", 1)
+                        docker_build_args[key] = value
+                    else:
+                        logger.warning(
+                            f"Invalid build arg format: {arg}. Expected KEY=VALUE"
+                        )
+
+                if docker_build_args:
+                    docker_build_kwargs["build_args"] = docker_build_args
+                    logger.info(f"Using build args: {list(docker_build_args.keys())}")
+
+            # Add secret if provided
+            if secret:
+                docker_build_kwargs["secrets"] = [secret]
+
+            if push:
+                # Build and push in one step for multi-platform builds
+                logger.info("Building and pushing image...")
+                docker_build_kwargs["push"] = (
+                    True  # Push directly after build for multi-platform
+                )
+                docker.buildx.build(**docker_build_kwargs)
+
+                logger.info(f"Successfully built and pushed {image_name}")
+            else:
+                # Build only
+                logger.info("Building image...")
+                docker.buildx.build(**docker_build_kwargs)
+
+                logger.info(f"Successfully built {image_name}")
+
+        except DockerException as error:
+            error_msg = error.stderr if error.stderr else str(error)
+            action = "build or push" if push else "build"
+            logger.error(f"{action.capitalize()} failed: {error_msg}", exc_info=True)
+            raise DockerBuildError(
+                f"Docker {action} failed: {error_msg}\n"
+                f"Build context: {build_context.path}\n"
+                f"Dockerfile path: {build_context.dockerfile_path}"
+            ) from error
+
+    return image_name
+
+
+def run_agent(manifest_path: str):
+    """Run an agent locally from the given manifest"""
+    import asyncio
+    import signal
+    import sys
+
+    # Flag to track if we're shutting down
+    shutting_down = False
+
+    def signal_handler(signum, frame):
+        """Handle signals by raising KeyboardInterrupt"""
+        nonlocal shutting_down
+        if shutting_down:
+            # If we're already shutting down and get another signal, force exit
+            print(f"\nForce exit on signal {signum}")
+            sys.exit(1)
+        
+        shutting_down = True
+        print(f"\nReceived signal {signum}, shutting down...")
+        raise KeyboardInterrupt()
+    
+    # Set up signal handling for the main thread
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    try:
+        asyncio.run(_run_agent(manifest_path))
+    except KeyboardInterrupt:
+        print("Shutdown completed.")
+        sys.exit(0)
+    except RunError as e:
+        raise RuntimeError(str(e)) from e