qodalis-cli-server-plugin-aws 1.0.0b13__py3-none-any.whl

qodalis_cli_aws/processors/ecs_processor.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import asyncio
+
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    get_positional_text,
+    CliCommandParameterDescriptor,
+    CliCommandProcessor,
+    CliProcessCommand,
+    ICliCommandParameterDescriptor,
+    ICliCommandProcessor,
+)
+
+from ..services.aws_credential_manager import AwsCredentialManager
+from ..utils.output_helpers import (
+    build_response,
+    build_error_response,
+    format_as_table,
+    apply_output_format,
+    CliServerTextOutput,
+)
+
+
+class _EcsClustersProcessor(CliCommandProcessor):
+    """Lists all ECS clusters with status and task counts."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "clusters"
+
+    @property
+    def description(self) -> str:
+        return "List ECS clusters"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches cluster ARNs and describes each cluster's status."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("ecs", region=str(region) if region else None)
+
+        try:
+            list_response = client.list_clusters()
+            cluster_arns = list_response.get("clusterArns", [])
+
+            if not cluster_arns:
+                return build_response([CliServerTextOutput(value="No ECS clusters found.", style="warning")])
+
+            describe_response = client.describe_clusters(clusters=cluster_arns)
+            clusters = describe_response.get("clusters", [])
+
+            rows = [
+                [
+                    c.get("clusterName", "(unknown)"),
+                    c.get("status", "(unknown)"),
+                    str(c.get("runningTasksCount", 0)),
+                    str(c.get("pendingTasksCount", 0)),
+                ]
+                for c in clusters
+            ]
+
+            table_output = format_as_table(["Cluster Name", "Status", "Running Tasks", "Pending Tasks"], rows)
+            return build_response([apply_output_format(command, table_output, clusters)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list ECS clusters: {exc}")
+
+
+class _EcsServicesProcessor(CliCommandProcessor):
+    """Lists ECS services in a specified cluster."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "services"
+
+    @property
+    def description(self) -> str:
+        return "List ECS services in a cluster"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and describes all services in the specified ECS cluster."""
+        cluster = get_positional_text(command)
+        if not cluster:
+            return build_error_response("Cluster name or ARN is required. Usage: ecs services <cluster>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("ecs", region=str(region) if region else None)
+
+        try:
+            list_response = client.list_services(cluster=cluster)
+            service_arns = list_response.get("serviceArns", [])
+
+            if not service_arns:
+                return build_response([CliServerTextOutput(value=f'No ECS services found in cluster "{cluster}".', style="warning")])
+
+            describe_response = client.describe_services(cluster=cluster, services=service_arns)
+            services = describe_response.get("services", [])
+
+            rows = [
+                [
+                    s.get("serviceName", "(unknown)"),
+                    s.get("status", "(unknown)"),
+                    str(s.get("desiredCount", 0)),
+                    str(s.get("runningCount", 0)),
+                    str(s.get("pendingCount", 0)),
+                ]
+                for s in services
+            ]
+
+            table_output = format_as_table(["Service Name", "Status", "Desired", "Running", "Pending"], rows)
+            return build_response([apply_output_format(command, table_output, services)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list ECS services: {exc}")
+
+
+class _EcsTasksProcessor(CliCommandProcessor):
+    """Lists ECS tasks in a specified cluster."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "tasks"
+
+    @property
+    def description(self) -> str:
+        return "List ECS tasks in a cluster"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and describes all tasks running in the specified ECS cluster."""
+        cluster = get_positional_text(command)
+        if not cluster:
+            return build_error_response("Cluster name or ARN is required. Usage: ecs tasks <cluster>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("ecs", region=str(region) if region else None)
+
+        try:
+            list_response = client.list_tasks(cluster=cluster)
+            task_arns = list_response.get("taskArns", [])
+
+            if not task_arns:
+                return build_response([CliServerTextOutput(value=f'No ECS tasks found in cluster "{cluster}".', style="warning")])
+
+            describe_response = client.describe_tasks(cluster=cluster, tasks=task_arns)
+            tasks = describe_response.get("tasks", [])
+
+            rows = []
+            for task in tasks:
+                task_arn = task.get("taskArn", "")
+                task_id = task_arn.split("/")[-1] if task_arn else "(unknown)"
+                task_def_arn = task.get("taskDefinitionArn", "")
+                task_def = task_def_arn.split("/")[-1] if task_def_arn else "(unknown)"
+                started_at = task.get("startedAt")
+                started_str = started_at.strftime("%Y-%m-%d %H:%M:%S") if started_at else "(not started)"
+                rows.append([task_id, task.get("lastStatus", "(unknown)"), task_def, started_str])
+
+            table_output = format_as_table(["Task ID", "Status", "Definition", "Started"], rows)
+            return build_response([apply_output_format(command, table_output, tasks)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list ECS tasks: {exc}")
+
+
+class AwsEcsProcessor(CliCommandProcessor):
+    """Parent processor for ECS sub-commands (clusters, services, tasks)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _EcsClustersProcessor(credential_manager),
+            _EcsServicesProcessor(credential_manager),
+            _EcsTasksProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "ecs"
+
+    @property
+    def description(self) -> str:
+        return "AWS ECS operations -- clusters, services, tasks"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for ECS operations."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""

qodalis_cli_aws/processors/iam_processor.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import asyncio
+
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    CliCommandParameterDescriptor,
+    CliCommandProcessor,
+    CliProcessCommand,
+    ICliCommandParameterDescriptor,
+    ICliCommandProcessor,
+)
+
+from ..services.aws_credential_manager import AwsCredentialManager
+from ..utils.output_helpers import (
+    build_response,
+    build_error_response,
+    format_as_table,
+    apply_output_format,
+    CliServerTextOutput,
+)
+
+
+class _IamUsersProcessor(CliCommandProcessor):
+    """Lists all IAM users."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "users"
+
+    @property
+    def description(self) -> str:
+        return "List IAM users"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and returns all IAM users as a table."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("iam", region=str(region) if region else None)
+
+        try:
+            response = client.list_users()
+            users = response.get("Users", [])
+
+            if not users:
+                return build_response([CliServerTextOutput(value="No IAM users found.", style="warning")])
+
+            rows = [
+                [
+                    user.get("UserName", "(unknown)"),
+                    user.get("UserId", "(unknown)"),
+                    user.get("Arn", "(unknown)"),
+                    user["CreateDate"].strftime("%Y-%m-%d") if user.get("CreateDate") else "(unknown)",
+                ]
+                for user in users
+            ]
+
+            table_output = format_as_table(["UserName", "UserId", "Arn", "CreateDate"], rows)
+            return build_response([apply_output_format(command, table_output, users)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list IAM users: {exc}")
+
+
+class _IamRolesProcessor(CliCommandProcessor):
+    """Lists all IAM roles."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "roles"
+
+    @property
+    def description(self) -> str:
+        return "List IAM roles"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and returns all IAM roles as a table."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("iam", region=str(region) if region else None)
+
+        try:
+            response = client.list_roles()
+            roles = response.get("Roles", [])
+
+            if not roles:
+                return build_response([CliServerTextOutput(value="No IAM roles found.", style="warning")])
+
+            rows = [
+                [
+                    role.get("RoleName", "(unknown)"),
+                    role.get("RoleId", "(unknown)"),
+                    role.get("Arn", "(unknown)"),
+                    role["CreateDate"].strftime("%Y-%m-%d") if role.get("CreateDate") else "(unknown)",
+                ]
+                for role in roles
+            ]
+
+            table_output = format_as_table(["RoleName", "RoleId", "Arn", "CreateDate"], rows)
+            return build_response([apply_output_format(command, table_output, roles)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list IAM roles: {exc}")
+
+
+class _IamPoliciesProcessor(CliCommandProcessor):
+    """Lists customer-managed IAM policies."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "policies"
+
+    @property
+    def description(self) -> str:
+        return "List IAM policies (local/customer-managed)"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and returns customer-managed IAM policies as a table."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("iam", region=str(region) if region else None)
+
+        try:
+            response = client.list_policies(Scope="Local")
+            policies = response.get("Policies", [])
+
+            if not policies:
+                return build_response([CliServerTextOutput(value="No IAM policies found.", style="warning")])
+
+            rows = [
+                [
+                    policy.get("PolicyName", "(unknown)"),
+                    policy.get("Arn", "(unknown)"),
+                    str(policy.get("AttachmentCount", 0)),
+                ]
+                for policy in policies
+            ]
+
+            table_output = format_as_table(["PolicyName", "Arn", "AttachmentCount"], rows)
+            return build_response([apply_output_format(command, table_output, policies)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list IAM policies: {exc}")
+
+
+class AwsIamProcessor(CliCommandProcessor):
+    """Parent processor for IAM sub-commands (users, roles, policies)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _IamUsersProcessor(credential_manager),
+            _IamRolesProcessor(credential_manager),
+            _IamPoliciesProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "iam"
+
+    @property
+    def description(self) -> str:
+        return "AWS IAM operations -- users, roles, policies"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for IAM operations."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""

qodalis_cli_aws/processors/lambda_processor.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+
+import json
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    get_positional_text,
+    CliCommandParameterDescriptor,
+    CliCommandProcessor,
+    CliProcessCommand,
+    ICliCommandParameterDescriptor,
+    ICliCommandProcessor,
+)
+
+from ..services.aws_credential_manager import AwsCredentialManager
+from ..utils.output_helpers import (
+    build_response,
+    build_error_response,
+    format_as_table,
+    format_as_json,
+    apply_output_format,
+    CliServerTextOutput,
+)
+
+
+class _LambdaListProcessor(CliCommandProcessor):
+    """Lists all Lambda functions with runtime and memory details."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "list"
+
+    @property
+    def description(self) -> str:
+        return "List Lambda functions"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="output", description="Output format (table|json|text)", required=False, type="string", aliases=["-o"], default_value="table"),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Fetches and returns all Lambda functions as a table."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("lambda", region=str(region) if region else None)
+
+        try:
+            response = client.list_functions()
+            functions = response.get("Functions", [])
+
+            if not functions:
+                return build_response([CliServerTextOutput(value="No Lambda functions found.", style="warning")])
+
+            rows = [
+                [
+                    fn.get("FunctionName", "(unknown)"),
+                    fn.get("Runtime", "(unknown)"),
+                    str(fn.get("MemorySize", "(unknown)")),
+                    fn.get("LastModified", "(unknown)"),
+                ]
+                for fn in functions
+            ]
+
+            table_output = format_as_table(["Name", "Runtime", "Memory (MB)", "Last Modified"], rows)
+            return build_response([apply_output_format(command, table_output, functions)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list Lambda functions: {exc}")
+
+
+class _LambdaInvokeProcessor(CliCommandProcessor):
+    """Invokes a Lambda function and returns the result."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "invoke"
+
+    @property
+    def description(self) -> str:
+        return "Invoke a Lambda function"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="payload", description="JSON payload to send to the function", required=False, type="string", aliases=["-p"]),
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Invokes the specified Lambda function with an optional JSON payload."""
+        function_name = get_positional_text(command)
+        if not function_name:
+            return build_error_response("Function name is required. Usage: lambda invoke <function-name>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("lambda", region=str(region) if region else None)
+
+        payload_str = command.args.get("payload")
+
+        try:
+            params: dict[str, Any] = {"FunctionName": function_name}
+            if payload_str:
+                params["Payload"] = str(payload_str).encode("utf-8")
+
+            response = client.invoke(**params)
+
+            if response.get("FunctionError"):
+                error_body = response["Payload"].read().decode("utf-8") if response.get("Payload") else "(no details)"
+                return build_error_response(f"Function error ({response['FunctionError']}): {error_body}")
+
+            result_body = response["Payload"].read().decode("utf-8") if response.get("Payload") else "null"
+
+            try:
+                parsed = json.loads(result_body)
+            except (json.JSONDecodeError, ValueError):
+                parsed = result_body
+
+            return build_response([
+                format_as_json({
+                    "StatusCode": response.get("StatusCode"),
+                    "ExecutedVersion": response.get("ExecutedVersion", "(unknown)"),
+                    "Result": parsed,
+                }),
+            ])
+        except Exception as exc:
+            return build_error_response(f"Failed to invoke function: {exc}")
+
+
+class _LambdaLogsProcessor(CliCommandProcessor):
+    """Fetches recent CloudWatch logs for a Lambda function."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "logs"
+
+    @property
+    def description(self) -> str:
+        return "View recent logs for a Lambda function"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="limit", description="Maximum number of log events (default: 50)", required=False, type="number", aliases=["-l"], default_value="50"),
+            CliCommandParameterDescriptor(name="region", description="AWS region override", required=False, type="string", aliases=["-r"]),
+        ]
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+    async def handle_structured_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> Any:
+        """Queries the ``/aws/lambda/<name>`` log group for recent events."""
+        function_name = get_positional_text(command)
+        if not function_name:
+            return build_error_response("Function name is required. Usage: lambda logs <function-name>")
+
+        try:
+            limit = int(command.args.get("limit", 50))
+        except (ValueError, TypeError):
+            return build_error_response("--limit must be a positive number.")
+
+        if limit <= 0:
+            return build_error_response("--limit must be a positive number.")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("logs", region=str(region) if region else None)
+
+        log_group_name = f"/aws/lambda/{function_name}"
+
+        try:
+            response = client.filter_log_events(logGroupName=log_group_name, limit=limit)
+            events = response.get("events", [])
+
+            if not events:
+                return build_response([CliServerTextOutput(value=f"No log events found for {log_group_name}.", style="warning")])
+
+            from datetime import datetime, timezone
+
+            lines = []
+            for event in events:
+                ts = event.get("timestamp")
+                if ts:
+                    timestamp = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+                else:
+                    timestamp = "(unknown)"
+                message = (event.get("message") or "").rstrip()
+                lines.append(f"{timestamp}  {message}")
+
+            return build_response([CliServerTextOutput(value="\n".join(lines))])
+        except Exception as exc:
+            return build_error_response(f"Failed to fetch logs: {exc}")
+
+
+class AwsLambdaProcessor(CliCommandProcessor):
+    """Parent processor for Lambda sub-commands (list, invoke, logs)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _LambdaListProcessor(credential_manager),
+            _LambdaInvokeProcessor(credential_manager),
+            _LambdaLogsProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "lambda"
+
+    @property
+    def description(self) -> str:
+        return "AWS Lambda operations -- list, invoke, and view logs"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for Lambda operations."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""