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

qodalis_cli_aws/processors/s3_processor.py

@@ -0,0 +1,446 @@
+from __future__ import annotations
+
+import asyncio
+
+import re
+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,
+    build_success_response,
+    format_as_list,
+    format_as_table,
+    apply_output_format,
+    is_dry_run,
+    CliServerTextOutput,
+)
+
+
+def _parse_s3_uri(uri: str) -> tuple[str, str] | None:
+    """Parses an S3 URI into a (bucket, key) tuple.
+
+    Args:
+        uri: An S3 URI in the form ``s3://bucket/key``.
+
+    Returns:
+        A tuple of ``(bucket, key)``, or ``None`` if the URI is invalid.
+    """
+    match = re.match(r"^s3://([^/]+)/?(.*)$", uri)
+    if not match:
+        return None
+    return match.group(1), match.group(2)
+
+
+def _format_bytes(num_bytes: int) -> str:
+    """Formats a byte count into a human-readable string.
+
+    Args:
+        num_bytes: Number of bytes.
+
+    Returns:
+        Formatted string (e.g. ``"1.5 MB"``).
+    """
+    if num_bytes == 0:
+        return "0 B"
+    units = ["B", "KB", "MB", "GB", "TB"]
+    i = 0
+    value = float(num_bytes)
+    while value >= 1024 and i < len(units) - 1:
+        value /= 1024
+        i += 1
+    return f"{value:.1f} {units[i]}"
+
+
+class _S3LsProcessor(CliCommandProcessor):
+    """Lists S3 buckets or objects within a bucket prefix."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "ls"
+
+    @property
+    def description(self) -> str:
+        return "List S3 buckets or objects in a bucket"
+
+    @property
+    def value_required(self) -> bool | None:
+        return False
+
+    @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:
+        """Lists buckets when no value is given, or objects at the specified S3 URI."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        value = get_positional_text(command)
+
+        if not value:
+            try:
+                response = client.list_buckets()
+                buckets = response.get("Buckets", [])
+
+                if not buckets:
+                    return build_response([CliServerTextOutput(value="No buckets found.", style="warning")])
+
+                items = []
+                for b in buckets:
+                    date = b["CreationDate"].strftime("%Y-%m-%d") if b.get("CreationDate") else "(unknown)"
+                    items.append(f"{date}  {b.get('Name', '(unknown)')}")
+
+                default_output = format_as_list(items)
+                return build_response([apply_output_format(command, default_output, buckets)])
+            except Exception as exc:
+                return build_error_response(f"Failed to list buckets: {exc}")
+
+        parsed = _parse_s3_uri(value)
+        if not parsed:
+            return build_error_response(f'Invalid S3 URI: "{value}". Expected format: s3://bucket[/prefix]')
+
+        bucket, prefix = parsed
+
+        try:
+            paginator = client.get_paginator("list_objects_v2")
+            pages = paginator.paginate(Bucket=bucket, Prefix=prefix or "")
+
+            objects: list[dict[str, Any]] = []
+            for page in pages:
+                objects.extend(page.get("Contents", []))
+
+            if not objects:
+                return build_response([CliServerTextOutput(value=f"No objects found in s3://{bucket}/{prefix}", style="warning")])
+
+            rows: list[list[str]] = []
+            for obj in objects:
+                date = obj["LastModified"].strftime("%Y-%m-%d %H:%M:%S") if obj.get("LastModified") else "(unknown)"
+                size = _format_bytes(obj.get("Size", 0))
+                rows.append([date, size, obj.get("Key", "")])
+
+            table_output = format_as_table(["Last Modified", "Size", "Key"], rows)
+            return build_response([apply_output_format(command, table_output, objects)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list objects: {exc}")
+
+
+class _S3CpProcessor(CliCommandProcessor):
+    """Copies objects between S3 locations (S3-to-S3 only)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "cp"
+
+    @property
+    def description(self) -> str:
+        return "Copy objects between S3 locations (S3-to-S3 only)"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="dest", description="Destination S3 URI (s3://bucket/key)", required=True, type="string", aliases=["-d"]),
+            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:
+        """Copies an S3 object from the source URI to the destination URI."""
+        source = get_positional_text(command)
+        dest = command.args.get("dest")
+
+        if not source:
+            return build_error_response("Source S3 URI is required. Usage: s3 cp <s3://bucket/key> --dest <s3://bucket/key>")
+
+        if not dest:
+            return build_error_response("Destination is required. Use --dest <s3://bucket/key>.")
+
+        src_parsed = _parse_s3_uri(source)
+        if not src_parsed or not src_parsed[1]:
+            return build_error_response(f'Invalid source S3 URI: "{source}". Expected format: s3://bucket/key')
+
+        dst_parsed = _parse_s3_uri(str(dest))
+        if not dst_parsed or not dst_parsed[1]:
+            return build_error_response(f'Invalid destination S3 URI: "{dest}". Expected format: s3://bucket/key')
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        try:
+            client.copy_object(
+                Bucket=dst_parsed[0],
+                Key=dst_parsed[1],
+                CopySource=f"{src_parsed[0]}/{src_parsed[1]}",
+            )
+            return build_success_response(f"Copied {source} to {dest}")
+        except Exception as exc:
+            return build_error_response(f"Failed to copy object: {exc}")
+
+
+class _S3RmProcessor(CliCommandProcessor):
+    """Deletes an S3 object."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "rm"
+
+    @property
+    def description(self) -> str:
+        return "Delete an S3 object"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="dry-run", description="Preview without deleting", required=False, type="boolean"),
+            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:
+        """Deletes the specified S3 object, or previews the action in dry-run mode."""
+        value = get_positional_text(command)
+        if not value:
+            return build_error_response("S3 URI is required. Usage: s3 rm <s3://bucket/key>")
+
+        parsed = _parse_s3_uri(value)
+        if not parsed or not parsed[1]:
+            return build_error_response(f'Invalid S3 URI: "{value}". Expected format: s3://bucket/key')
+
+        if is_dry_run(command):
+            return build_response([CliServerTextOutput(value=f"[DRY RUN] Would delete {value}", style="warning")])
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        try:
+            client.delete_object(Bucket=parsed[0], Key=parsed[1])
+            return build_success_response(f"Deleted {value}")
+        except Exception as exc:
+            return build_error_response(f"Failed to delete object: {exc}")
+
+
+class _S3MbProcessor(CliCommandProcessor):
+    """Creates a new S3 bucket."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "mb"
+
+    @property
+    def description(self) -> str:
+        return "Create an S3 bucket"
+
+    @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"]),
+        ]
+
+    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:
+        """Creates a new S3 bucket with the specified name."""
+        bucket_name = get_positional_text(command)
+        if not bucket_name:
+            return build_error_response("Bucket name is required. Usage: s3 mb <bucket-name>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        try:
+            client.create_bucket(Bucket=bucket_name)
+            return build_success_response(f'Bucket "{bucket_name}" created successfully.')
+        except Exception as exc:
+            return build_error_response(f"Failed to create bucket: {exc}")
+
+
+class _S3RbProcessor(CliCommandProcessor):
+    """Deletes an S3 bucket."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "rb"
+
+    @property
+    def description(self) -> str:
+        return "Delete an S3 bucket"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="dry-run", description="Preview without deleting", required=False, type="boolean"),
+            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:
+        """Deletes the specified bucket, or previews the action in dry-run mode."""
+        bucket_name = get_positional_text(command)
+        if not bucket_name:
+            return build_error_response("Bucket name is required. Usage: s3 rb <bucket-name>")
+
+        if is_dry_run(command):
+            return build_response([CliServerTextOutput(value=f'[DRY RUN] Would delete bucket "{bucket_name}"', style="warning")])
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        try:
+            client.delete_bucket(Bucket=bucket_name)
+            return build_success_response(f'Bucket "{bucket_name}" deleted successfully.')
+        except Exception as exc:
+            return build_error_response(f"Failed to delete bucket: {exc}")
+
+
+class _S3PresignProcessor(CliCommandProcessor):
+    """Generates a pre-signed URL for an S3 object."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "presign"
+
+    @property
+    def description(self) -> str:
+        return "Generate a pre-signed URL for an S3 object"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="expires", description="URL expiration in seconds (default: 3600)", required=False, type="number", aliases=["-e"], default_value="3600"),
+            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:
+        """Generates and returns a time-limited pre-signed URL for the S3 object."""
+        value = get_positional_text(command)
+        if not value:
+            return build_error_response("S3 URI is required. Usage: s3 presign <s3://bucket/key>")
+
+        parsed = _parse_s3_uri(value)
+        if not parsed or not parsed[1]:
+            return build_error_response(f'Invalid S3 URI: "{value}". Expected format: s3://bucket/key')
+
+        try:
+            expires_in = int(command.args.get("expires", 3600))
+        except (ValueError, TypeError):
+            return build_error_response("--expires must be a positive number of seconds.")
+
+        if expires_in <= 0:
+            return build_error_response("--expires must be a positive number of seconds.")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("s3", region=str(region) if region else None)
+
+        try:
+            url = client.generate_presigned_url(
+                "get_object",
+                Params={"Bucket": parsed[0], "Key": parsed[1]},
+                ExpiresIn=expires_in,
+            )
+            return build_response([
+                CliServerTextOutput(value=url),
+                CliServerTextOutput(value=f"Expires in {expires_in} seconds.", style="info"),
+            ])
+        except Exception as exc:
+            return build_error_response(f"Failed to generate pre-signed URL: {exc}")
+
+
+class AwsS3Processor(CliCommandProcessor):
+    """Parent processor for S3 sub-commands (ls, cp, rm, mb, rb, presign)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _S3LsProcessor(credential_manager),
+            _S3CpProcessor(credential_manager),
+            _S3RmProcessor(credential_manager),
+            _S3MbProcessor(credential_manager),
+            _S3RbProcessor(credential_manager),
+            _S3PresignProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "s3"
+
+    @property
+    def description(self) -> str:
+        return "Amazon S3 operations -- list, copy, remove objects and buckets"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for S3 operations."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""

qodalis_cli_aws/processors/sns_processor.py

@@ -0,0 +1,205 @@
+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,
+    build_success_response,
+    format_as_table,
+    format_as_list,
+    apply_output_format,
+    CliServerTextOutput,
+)
+
+
+class _SnsTopicsProcessor(CliCommandProcessor):
+    """Lists all SNS topics."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "topics"
+
+    @property
+    def description(self) -> str:
+        return "List SNS topics"
+
+    @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 SNS topic ARNs."""
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("sns", region=str(region) if region else None)
+
+        try:
+            response = client.list_topics()
+            topics = response.get("Topics", [])
+
+            if not topics:
+                return build_response([CliServerTextOutput(value="No SNS topics found.", style="warning")])
+
+            arns = [t.get("TopicArn", "(unknown)") for t in topics]
+            list_output = format_as_list(arns)
+            return build_response([apply_output_format(command, list_output, topics)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list SNS topics: {exc}")
+
+
+class _SnsPublishProcessor(CliCommandProcessor):
+    """Publishes a message to an SNS topic."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "publish"
+
+    @property
+    def description(self) -> str:
+        return "Publish a message to an SNS topic"
+
+    @property
+    def value_required(self) -> bool | None:
+        return True
+
+    @property
+    def parameters(self) -> list[ICliCommandParameterDescriptor]:
+        return [
+            CliCommandParameterDescriptor(name="message", description="Message to publish", required=True, type="string", aliases=["-m"]),
+            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:
+        """Publishes the provided message to the specified SNS topic ARN."""
+        topic_arn = get_positional_text(command)
+        if not topic_arn:
+            return build_error_response("Topic ARN is required. Usage: sns publish <topic-arn> --message <message>")
+
+        message = command.args.get("message")
+        if not message:
+            return build_error_response("--message is required. Usage: sns publish <topic-arn> --message <message>")
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("sns", region=str(region) if region else None)
+
+        try:
+            response = client.publish(TopicArn=topic_arn, Message=str(message))
+            return build_success_response(f"Message published successfully. MessageId: {response.get('MessageId', '(unknown)')}")
+        except Exception as exc:
+            return build_error_response(f"Failed to publish message: {exc}")
+
+
+class _SnsSubscriptionsProcessor(CliCommandProcessor):
+    """Lists SNS subscriptions, optionally filtered by topic ARN."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._credential_manager = credential_manager
+
+    @property
+    def command(self) -> str:
+        return "subscriptions"
+
+    @property
+    def description(self) -> str:
+        return "List SNS subscriptions (optionally filtered by topic ARN)"
+
+    @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 subscriptions for a specific topic or all subscriptions."""
+        topic_arn = get_positional_text(command) or None
+
+        region = command.args.get("region")
+        client = self._credential_manager.get_client("sns", region=str(region) if region else None)
+
+        try:
+            if topic_arn:
+                response = client.list_subscriptions_by_topic(TopicArn=topic_arn)
+            else:
+                response = client.list_subscriptions()
+
+            subscriptions = response.get("Subscriptions", [])
+
+            if not subscriptions:
+                return build_response([CliServerTextOutput(value="No SNS subscriptions found.", style="warning")])
+
+            rows = [
+                [
+                    sub.get("SubscriptionArn", "(unknown)"),
+                    sub.get("Protocol", "(unknown)"),
+                    sub.get("Endpoint", "(unknown)"),
+                    sub.get("TopicArn", "(unknown)"),
+                ]
+                for sub in subscriptions
+            ]
+
+            table_output = format_as_table(["SubscriptionArn", "Protocol", "Endpoint", "TopicArn"], rows)
+            return build_response([apply_output_format(command, table_output, subscriptions)])
+        except Exception as exc:
+            return build_error_response(f"Failed to list SNS subscriptions: {exc}")
+
+
+class AwsSnsProcessor(CliCommandProcessor):
+    """Parent processor for SNS sub-commands (topics, publish, subscriptions)."""
+
+    def __init__(self, credential_manager: AwsCredentialManager) -> None:
+        super().__init__()
+        self._sub_processors: list[ICliCommandProcessor] = [
+            _SnsTopicsProcessor(credential_manager),
+            _SnsPublishProcessor(credential_manager),
+            _SnsSubscriptionsProcessor(credential_manager),
+        ]
+
+    @property
+    def command(self) -> str:
+        return "sns"
+
+    @property
+    def description(self) -> str:
+        return "AWS SNS operations -- topics, publish, subscriptions"
+
+    @property
+    def processors(self) -> list[ICliCommandProcessor]:
+        """Returns sub-processors for SNS operations."""
+        return self._sub_processors
+
+    async def handle_async(self, command: CliProcessCommand, cancellation_event: asyncio.Event | None = None) -> str:
+        return ""