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

qodalis_cli_aws/__init__.py

@@ -0,0 +1,5 @@
+"""Qodalis CLI AWS plugin — AWS cloud resource management commands."""
+
+from .aws_module import AwsModule
+
+__all__ = ["AwsModule"]

qodalis_cli_aws/aws_module.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from qodalis_cli_server_abstractions import (
+    CliModule,
+    ICliCommandProcessor,
+)
+
+from .processors.aws_command_processor import AwsCommandProcessor
+
+
+class AwsModule(CliModule):
+    """AWS cloud resource management module."""
+
+    @property
+    def name(self) -> str:
+        """Returns the module name."""
+        return "aws"
+
+    @property
+    def version(self) -> str:
+        """Returns the module version."""
+        return "1.0.0"
+
+    @property
+    def description(self) -> str:
+        """Returns a human-readable description of the module."""
+        return "Provides AWS cloud resource management commands"
+
+    @property
+    def processors(self) -> Sequence[ICliCommandProcessor]:
+        """Returns the command processors provided by this module."""
+        return [AwsCommandProcessor()]

qodalis_cli_aws/processors/aws_command_processor.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import asyncio
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from qodalis_cli_server_abstractions import (
+    CliCommandParameterDescriptor,
+    CliCommandProcessor,
+    CliProcessCommand,
+    ICliCommandParameterDescriptor,
+    ICliCommandProcessor,
+)
+
+from ..services.aws_config_service import AwsConfigService
+from ..services.aws_credential_manager import AwsCredentialManager
+from ..utils.output_helpers import (
+    build_response,
+    build_error_response,
+    build_success_response,
+    format_as_key_value,
+    format_as_list,
+    CliServerTextOutput,
+)
+from .s3_processor import AwsS3Processor
+from .ec2_processor import AwsEc2Processor
+from .lambda_processor import AwsLambdaProcessor
+from .cloudwatch_processor import AwsCloudWatchProcessor
+from .sns_processor import AwsSnsProcessor
+from .sqs_processor import AwsSqsProcessor
+from .iam_processor import AwsIamProcessor
+from .dynamodb_processor import AwsDynamoDbProcessor
+from .ecs_processor import AwsEcsProcessor
+
+
+class _AwsConfigureSetProcessor(CliCommandProcessor):
+    """Handles ``aws configure set`` to update AWS credentials and region."""
+
+    def __init__(self, config_service: AwsConfigService, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._config_service = config_service
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "set"
+
+    @property
+    def description(self) -> str:
+        return "Set AWS credentials and region"
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="key", description="AWS access key ID", required=False, type="string", aliases=["-k"]),
+            CliCommandParameterDescriptor(name="secret", description="AWS secret access key", required=False, type="string", aliases=["-s"]),
+            CliCommandParameterDescriptor(name="region", description="AWS region", required=False, type="string", aliases=["-r"]),
+            CliCommandParameterDescriptor(name="profile", description="AWS profile name", required=False, type="string", aliases=["-p"], default_value="default"),
+        ]
+
+    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:
+        """Applies credential, region, and profile updates from arguments."""
+        key = command.args.get("key")
+        secret = command.args.get("secret")
+        region = command.args.get("region")
+        profile = command.args.get("profile")
+
+        if key and secret:
+            self._config_service.set_credentials(str(key), str(secret))
+            self._credential_manager.clear_cache()
+        elif key or secret:
+            return build_error_response("Both --key and --secret must be provided together.")
+
+        if region:
+            self._config_service.set_region(str(region))
+            self._credential_manager.clear_cache()
+
+        if profile:
+            self._config_service.set_profile(str(profile))
+            self._credential_manager.clear_cache()
+
+        if not key and not secret and not region and not profile:
+            return build_error_response("Provide at least one of --key/--secret, --region, or --profile.")
+
+        return build_success_response("AWS configuration updated.")
+
+
+class _AwsConfigureGetProcessor(CliCommandProcessor):
+    """Handles ``aws configure get`` to display current configuration."""
+
+    def __init__(self, config_service: AwsConfigService) -> None:
+        super().__init__()
+        self._config_service = config_service
+
+    @property
+    def command(self) -> str:
+        return "get"
+
+    @property
+    def description(self) -> str:
+        return "Show current AWS configuration (secrets masked)"
+
+    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:
+        """Returns the current AWS config summary with secrets masked."""
+        summary = self._config_service.get_config_summary()
+        entries = {
+            "Access Key ID": summary.get("access_key_id") or "(not set)",
+            "Secret Access Key": summary.get("secret_access_key") or "(not set)",
+            "Region": summary.get("region") or "(not set)",
+            "Profile": summary.get("profile") or "default",
+        }
+        return build_response([format_as_key_value(entries)])
+
+
+class _AwsConfigureProfilesProcessor(CliCommandProcessor):
+    """Handles ``aws configure profiles`` to list locally available AWS profiles."""
+
+    @property
+    def command(self) -> str:
+        return "profiles"
+
+    @property
+    def description(self) -> str:
+        return "List available AWS profiles from ~/.aws/credentials and ~/.aws/config"
+
+    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:
+        """Parses AWS config files and returns discovered profile names."""
+        profiles: set[str] = set()
+
+        home = Path.home()
+        credentials_path = home / ".aws" / "credentials"
+        config_path = home / ".aws" / "config"
+
+        self._parse_profiles(credentials_path, re.compile(r"^\[([^\]]+)\]"), profiles)
+        self._parse_profiles(config_path, re.compile(r"^\[(?:profile\s+)?([^\]]+)\]"), profiles)
+
+        items = sorted(profiles)
+
+        if not items:
+            return build_response([
+                CliServerTextOutput(value="No AWS profiles found in ~/.aws/credentials or ~/.aws/config.", style="warning"),
+            ])
+
+        return build_response([format_as_list(items)])
+
+    @staticmethod
+    def _parse_profiles(file_path: Path, pattern: re.Pattern[str], profiles: set[str]) -> None:
+        """Extracts profile names from an AWS config or credentials file.
+
+        Args:
+            file_path: Path to the AWS config file.
+            pattern: Regex to match profile section headers.
+            profiles: Set to add discovered profile names to.
+        """
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            for line in content.splitlines():
+                match = pattern.match(line.strip())
+                if match:
+                    profiles.add(match.group(1).strip())
+        except (OSError, IOError):
+            pass
+
+
+class _AwsConfigureProcessor(CliCommandProcessor):
+    """Parent processor for ``aws configure`` sub-commands."""
+
+    def __init__(self, config_service: AwsConfigService, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _AwsConfigureSetProcessor(config_service, credential_manager),
+            _AwsConfigureGetProcessor(config_service),
+            _AwsConfigureProfilesProcessor(),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "configure"
+
+    @property
+    def description(self) -> str:
+        return "Manage AWS credentials and configuration"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for set, get, and profiles commands."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""
+
+
+class _AwsStatusProcessor(CliCommandProcessor):
+    """Handles ``aws status`` to verify AWS connectivity via STS."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "status"
+
+    @property
+    def description(self) -> str:
+        return "Test AWS connectivity using STS GetCallerIdentity"
+
+    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:
+        """Calls STS GetCallerIdentity and returns account details."""
+        try:
+            client = self._credential_manager.get_client("sts")
+            response = client.get_caller_identity()
+
+            entries = {
+                "Account": response.get("Account", "(unknown)"),
+                "Arn": response.get("Arn", "(unknown)"),
+                "UserId": response.get("UserId", "(unknown)"),
+            }
+
+            return build_response([
+                CliServerTextOutput(value="AWS connection successful.", style="success"),
+                format_as_key_value(entries),
+            ])
+        except Exception as exc:
+            err_name = type(exc).__name__
+            err_msg = str(exc)
+            if "credentials" in err_msg.lower() or err_name in ("NoCredentialsError", "PartialCredentialsError"):
+                return build_error_response(
+                    'No AWS credentials configured. Run "aws configure set --key <key> --secret <secret>" '
+                    "or set AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY environment variables."
+                )
+            return build_error_response(f"AWS status check failed: {exc}")
+
+
+class AwsCommandProcessor(CliCommandProcessor):
+    """Root processor for all ``aws`` commands.
+
+    Registers sub-processors for configure, status, and all AWS service
+    commands (S3, EC2, Lambda, CloudWatch, SNS, SQS, ECS, DynamoDB, IAM).
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._config_service = AwsConfigService()
+        self._credential_manager = AwsCredentialManager(self._config_service)
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _AwsConfigureProcessor(self._config_service, self._credential_manager),
+            _AwsStatusProcessor(self._credential_manager),
+            AwsS3Processor(self._credential_manager),
+            AwsEc2Processor(self._credential_manager),
+            AwsLambdaProcessor(self._credential_manager),
+            AwsCloudWatchProcessor(self._credential_manager),
+            AwsSnsProcessor(self._credential_manager),
+            AwsSqsProcessor(self._credential_manager),
+            AwsEcsProcessor(self._credential_manager),
+            AwsDynamoDbProcessor(self._credential_manager),
+            AwsIamProcessor(self._credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "aws"
+
+    @property
+    def description(self) -> str:
+        return "AWS cloud resource management"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns all registered AWS service sub-processors."""
+        return self._sub_processors
+
+    def get_credential_manager(self) -> AwsCredentialManager:
+        """Returns the shared credential manager instance."""
+        return self._credential_manager
+
+    def get_config_service(self) -> AwsConfigService:
+        """Returns the shared config service instance."""
+        return self._config_service
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""

qodalis_cli_aws/processors/cloudwatch_processor.py

@@ -0,0 +1,237 @@
+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 _CloudWatchAlarmsProcessor(CliCommandProcessor):
+    """Lists CloudWatch metric alarms."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "alarms"
+
+    @property
+    def description(self) -> str:
+        return "List CloudWatch alarms"
+
+    @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 CloudWatch metric alarms."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("cloudwatch", region=str(region) if region else None)
+
+        try:
+            response = client.describe_alarms()
+            alarms = response.get("MetricAlarms", [])
+
+            if not alarms:
+                return build_response([CliServerTextOutput(value="No alarms found.", style="warning")])
+
+            rows = [
+                [
+                    a.get("AlarmName", "(unknown)"),
+                    a.get("StateValue", "(unknown)"),
+                    a.get("MetricName", "(unknown)"),
+                    a.get("Namespace", "(unknown)"),
+                ]
+                for a in alarms
+            ]
+
+            table_output = format_as_table(["Name", "State", "Metric", "Namespace"], rows)
+            return build_response([apply_output_format(command, table_output, alarms)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list alarms: {exc}")
+
+
+class _CloudWatchLogsProcessor(CliCommandProcessor):
+    """Fetches log events from a CloudWatch log group."""
+
+    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 "Fetch log events from a CloudWatch log group"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="filter", description="Filter pattern for log events", required=False, type="string", aliases=["-f"]),
+            CliCommandParameterDescriptor(name="limit", description="Maximum number of events to return (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:
+        """Retrieves and formats recent log events from the specified log group."""
+        log_group_name = get_positional_text(command)
+        if not log_group_name:
+            return build_error_response("Log group name is required. Usage: cloudwatch logs <log-group>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("logs", region=str(region) if region else None)
+
+        try:
+            limit = int(command.args.get("limit", 50))
+        except (ValueError, TypeError):
+            limit = 50
+
+        filter_pattern = command.args.get("filter")
+
+        try:
+            kwargs: dict[str, Any] = {"logGroupName": log_group_name, "limit": limit}
+            if filter_pattern:
+                kwargs["filterPattern"] = str(filter_pattern)
+
+            response = client.filter_log_events(**kwargs)
+            events = response.get("events", [])
+
+            if not events:
+                return build_response([CliServerTextOutput(value="No log events found.", style="warning")])
+
+            from datetime import datetime, timezone
+
+            lines = []
+            for e in events:
+                ts = e.get("timestamp")
+                if ts:
+                    timestamp = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).isoformat()
+                else:
+                    timestamp = "(unknown)"
+                message = (e.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 log events: {exc}")
+
+
+class _CloudWatchMetricsProcessor(CliCommandProcessor):
+    """Lists CloudWatch metrics for a given namespace."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "metrics"
+
+    @property
+    def description(self) -> str:
+        return "List CloudWatch metrics for a namespace"
+
+    @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:
+        """Queries metrics for the specified CloudWatch namespace."""
+        namespace = get_positional_text(command)
+        if not namespace:
+            return build_error_response("Namespace is required. Usage: cloudwatch metrics <namespace>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("cloudwatch", region=str(region) if region else None)
+
+        try:
+            response = client.list_metrics(Namespace=namespace)
+            metrics = response.get("Metrics", [])
+
+            if not metrics:
+                return build_response([CliServerTextOutput(value=f'No metrics found for namespace "{namespace}".', style="warning")])
+
+            rows = [
+                [
+                    m.get("MetricName", "(unknown)"),
+                    ", ".join(f"{d.get('Name', '')}={d.get('Value', '')}" for d in m.get("Dimensions", [])),
+                ]
+                for m in metrics
+            ]
+
+            table_output = format_as_table(["MetricName", "Dimensions"], rows)
+            return build_response([apply_output_format(command, table_output, metrics)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list metrics: {exc}")
+
+
+class AwsCloudWatchProcessor(CliCommandProcessor):
+    """Parent processor for CloudWatch sub-commands (alarms, logs, metrics)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _CloudWatchAlarmsProcessor(credential_manager),
+            _CloudWatchLogsProcessor(credential_manager),
+            _CloudWatchMetricsProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "cloudwatch"
+
+    @property
+    def description(self) -> str:
+        return "Amazon CloudWatch -- alarms, logs, and metrics"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for alarms, logs, and metrics."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""