lambda-forge-cli-aws 1.0.0__py3-none-any.whl

lambdaforge/deploy.py

@@ -0,0 +1,308 @@
+"""Deploy command — deploys the current Lambda to AWS using CDK."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def deploy_lambda(
+    project_path: Path,
+    stack_name: str | None = None,
+    env: str = "dev",
+) -> None:
+    """Deploy a Lambda project to AWS.
+
+    Args:
+        project_path: Path to the Lambda project
+        stack_name: Optional CDK stack name to deploy (deploys all if not specified)
+        env: Target environment (dev, staging, prod)
+    """
+    infra_dir = project_path / "infrastructure"
+    if not infra_dir.exists():
+        console.print(f"[red]✗ No infrastructure/ directory found in {project_path}[/red]")
+        console.print("[yellow]Run `lambdaforge new` first or set up CDK manually.[/yellow]")
+        return
+
+    # Pre-flight checks
+    if not _preflight_check(project_path):
+        return
+
+    # Confirm prod deploy
+    if env == "prod":
+        console.print("[yellow]⚠ Deploying to PRODUCTION environment[/yellow]")
+        import click
+
+        if not click.confirm("Are you sure?", default=False):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    # Bundle Python dependencies
+    console.print("[dim]Bundling Python dependencies...[/dim]")
+    if not _bundle_dependencies(project_path):
+        console.print("[yellow]⚠ Dependency bundling failed. Deploy may fail at runtime.[/yellow]")
+
+    # Install CDK dependencies
+    if (infra_dir / "package.json").exists():
+        if not (infra_dir / "node_modules").exists():
+            console.print("[dim]Installing CDK dependencies...[/dim]")
+            subprocess.run(
+                ["npm", "install"],
+                cwd=infra_dir,
+                check=True,
+                capture_output=True,
+            )
+
+    # Build cdk deploy command with environment context
+    cmd = ["npx", "cdk", "deploy", "--require-approval", "never", "-c", f"env={env}"]
+    if stack_name:
+        cmd.append(stack_name)
+
+    # Run cdk deploy with progress display
+    console.print(f"[dim]Deploying to [bold]{env}[/bold]...[/dim]")
+
+    try:
+        _run_with_progress(cmd, cwd=infra_dir)
+        console.print(f"[green]✓ Deployment successful ({env})[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Deployment failed (exit code {e.returncode})[/red]")
+    except FileNotFoundError:
+        console.print("[red]✗ npx/cdk command not found[/red]")
+
+
+def bootstrap_account(region: str = "us-east-1") -> None:
+    """Bootstrap CDK in the AWS account/region.
+
+    Args:
+        region: AWS region to bootstrap
+    """
+    if not shutil.which("node"):
+        console.print("[red]✗ Node.js not found. Install Node.js 18+ first.[/red]")
+        return
+
+    try:
+        result = subprocess.run(
+            ["aws", "sts", "get-caller-identity", "--query", "Account", "--output", "text"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        account_id = result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        console.print("[red]✗ Cannot determine AWS account. Check AWS credentials.[/red]")
+        return
+
+    console.print(f"[dim]Bootstrapping CDK in {account_id}/{region}...[/dim]")
+
+    try:
+        subprocess.run(
+            ["npx", "cdk", "bootstrap", f"aws://{account_id}/{region}"],
+            check=True,
+        )
+        console.print(f"[green]✓ CDK bootstrapped in {account_id}/{region}[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Bootstrap failed (exit code {e.returncode})[/red]")
+
+
+def destroy_stack(
+    project_path: Path,
+    stack_name: str | None = None,
+    env: str = "dev",
+) -> None:
+    """Destroy the CDK stack for a Lambda project.
+
+    Args:
+        project_path: Path to the Lambda project
+        stack_name: Optional stack name (auto-detected if not provided)
+        env: Target environment to destroy
+    """
+    infra_dir = project_path / "infrastructure"
+    if not infra_dir.exists():
+        console.print("[red]✗ No infrastructure/ directory found[/red]")
+        return
+
+    cmd = ["npx", "cdk", "destroy", "--force", "-c", f"env={env}"]
+    if stack_name:
+        cmd.append(stack_name)
+
+    console.print(f"[dim]Destroying stack ({env})...[/dim]")
+
+    try:
+        subprocess.run(cmd, cwd=infra_dir, check=True)
+        console.print(f"[green]✓ Stack destroyed ({env})[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Destroy failed (exit code {e.returncode})[/red]")
+
+
+def _preflight_check(project_path: Path) -> bool:
+    """Run pre-flight checks before deploying. Returns True if all pass."""
+    errors = []
+
+    if not shutil.which("node"):
+        errors.append("Node.js not found. Install Node.js 18+.")
+
+    try:
+        subprocess.run(
+            ["aws", "sts", "get-caller-identity"],
+            capture_output=True,
+            check=True,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        errors.append("AWS credentials not configured. Run `aws configure`.")
+
+    src_dir = project_path / "src"
+    if not src_dir.exists():
+        errors.append(f"Source directory not found: {src_dir}")
+
+    if errors:
+        console.print("[red]✗ Pre-flight checks failed:[/red]")
+        for err in errors:
+            console.print(f"  [red]• {err}[/red]")
+        return False
+
+    return True
+
+
+def _bundle_dependencies(project_path: Path) -> bool:
+    """Bundle Python dependencies into src/ for Lambda deployment.
+
+    Installs requirements.txt targeting Linux ARM64.
+    Returns True on success.
+    """
+    src_dir = project_path / "src"
+    requirements = project_path / "requirements.txt"
+
+    if not requirements.exists():
+        console.print("[dim]No requirements.txt found, skipping bundling.[/dim]")
+        return True
+
+    try:
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--target",
+                str(src_dir),
+                "--platform",
+                "manylinux2014_aarch64",
+                "--only-binary=:all:",
+                "--python-version",
+                "3.12",
+                "--upgrade",
+                "--quiet",
+                "-r",
+                str(requirements),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        console.print("[green]✓ Dependencies bundled[/green]")
+        return True
+    except subprocess.CalledProcessError:
+        # Fallback: install without platform constraint (pure Python packages)
+        try:
+            subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "--target",
+                    str(src_dir),
+                    "--upgrade",
+                    "--quiet",
+                    "-r",
+                    str(requirements),
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            console.print("[green]✓ Dependencies bundled (fallback)[/green]")
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+def _run_with_progress(cmd: list[str], cwd: Path) -> None:
+    """Run a command showing Rich progress based on CDK output.
+
+    Parses CDK output lines to show a live status spinner with
+    the current resource being created/updated/deleted.
+
+    Args:
+        cmd: Command as list (e.g., ["npx", "cdk", "deploy", ...])
+        cwd: Working directory
+
+    Raises:
+        subprocess.CalledProcessError: If the command fails
+    """
+    import re
+
+    from rich.live import Live
+    from rich.spinner import Spinner
+
+    resources_done = 0
+    outputs: list[str] = []
+
+    process = subprocess.Popen(
+        cmd,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+
+    # Pattern: StackName | 3/12 | timestamp | STATUS | AWS::Type | Name
+    progress_pattern = re.compile(
+        r"\|\s*(\d+)/(\d+)\s*\|.*?\|\s*([\w_]+)\s*\|\s*([\w:]+)\s*\|\s*(.*)"
+    )
+    output_pattern = re.compile(r"^(\w[\w.-]+)\s*=\s*(.+)$")
+
+    with Live(Spinner("dots", text="Starting deployment..."), console=console, transient=True):
+        assert process.stdout is not None
+        for line in iter(process.stdout.readline, ""):
+            line = line.strip()
+            if not line:
+                continue
+
+            match = progress_pattern.search(line)
+            if match:
+                done, total, status, resource_type, name = match.groups()
+                resources_done = int(done)
+                total_resources = int(total)
+                short_type = resource_type.split("::")[-1]
+                short_name = name.split("(")[-1].rstrip(")")[:30] if "(" in name else name[:30]
+
+                if "COMPLETE" in status and "ROLLBACK" not in status:
+                    console.print(
+                        f"  [green]✓[/green] {short_type} ({short_name}) "
+                        f"[dim]{resources_done}/{total_resources}[/dim]"
+                    )
+                elif "FAILED" in status:
+                    console.print(f"  [red]✗[/red] {short_type} ({short_name}) — {status}")
+                continue
+
+            output_match = output_pattern.match(line)
+            if output_match:
+                outputs.append(line)
+
+    process.wait()
+
+    if outputs:
+        console.print()
+        console.print("[bold]Outputs:[/bold]")
+        for out in outputs:
+            console.print(f"  [cyan]{out}[/cyan]")
+
+    if process.returncode != 0:
+        raise subprocess.CalledProcessError(process.returncode, cmd)

lambdaforge/logs.py

@@ -0,0 +1,185 @@
+"""Logs command — tail CloudWatch logs for the deployed Lambda."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+console = Console()
+
+
+def show_logs(
+    project_path: Path,
+    env: str = "dev",
+    lines: int = 50,
+    errors_only: bool = False,
+) -> None:
+    """Show CloudWatch logs for the deployed Lambda.
+
+    Args:
+        project_path: Path to the Lambda project
+        env: Target environment
+        lines: Number of log lines to retrieve
+        errors_only: Only show ERROR level logs
+    """
+    project_name = project_path.name.replace("_", "-")
+    log_group = f"/aws/lambda/{project_name}-{env}"
+
+    if not _log_group_exists(log_group):
+        slug = project_path.name.replace("-", "_")
+        log_group = f"/aws/lambda/{slug}-{env}"
+        if not _log_group_exists(log_group):
+            console.print(f"[yellow]No logs found for {project_name} ({env})[/yellow]")
+            console.print("[dim]Has the Lambda been invoked at least once?[/dim]")
+            return
+
+    console.print(f"[dim]Log group: {log_group}[/dim]")
+    console.print(f"[dim]Last {lines} events{' (errors only)' if errors_only else ''}[/dim]")
+    console.print()
+
+    events = _get_log_events(log_group, limit=lines)
+
+    if not events:
+        console.print("[yellow]No log events found.[/yellow]")
+        return
+
+    if errors_only:
+        events = [e for e in events if _is_error_event(e)]
+        if not events:
+            console.print("[green]No errors found.[/green]")
+            return
+
+    for event in events:
+        _print_log_event(event)
+
+
+def _log_group_exists(log_group: str) -> bool:
+    """Check if a CloudWatch log group exists."""
+    try:
+        subprocess.run(
+            [
+                "aws",
+                "logs",
+                "describe-log-groups",
+                "--log-group-name-prefix",
+                log_group,
+                "--limit",
+                "1",
+                "--output",
+                "json",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def _get_log_events(log_group: str, limit: int = 50) -> list[dict[str, Any]]:
+    """Fetch recent log events from CloudWatch."""
+    try:
+        result = subprocess.run(
+            [
+                "aws",
+                "logs",
+                "describe-log-streams",
+                "--log-group-name",
+                log_group,
+                "--order-by",
+                "LastEventTime",
+                "--descending",
+                "--limit",
+                "3",
+                "--output",
+                "json",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        streams_data = json.loads(result.stdout)
+        streams = streams_data.get("logStreams", [])
+
+        if not streams:
+            return []
+
+        all_events = []
+        for stream in streams[:3]:
+            stream_name = stream["logStreamName"]
+            result = subprocess.run(
+                [
+                    "aws",
+                    "logs",
+                    "get-log-events",
+                    "--log-group-name",
+                    log_group,
+                    "--log-stream-name",
+                    stream_name,
+                    "--limit",
+                    str(min(limit, 50)),
+                    "--output",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            events_data = json.loads(result.stdout)
+            events = events_data.get("events", [])
+            all_events.extend(events)
+
+        all_events.sort(key=lambda e: e.get("timestamp", 0))
+        return all_events[-limit:]
+
+    except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError):
+        return []
+
+
+def _is_error_event(event: dict[str, Any]) -> bool:
+    """Check if a log event is an error."""
+    message = event.get("message", "")
+    error_indicators = ["[ERROR]", "ERROR", "Traceback", "Exception", "FAILED"]
+    return any(indicator in message for indicator in error_indicators)
+
+
+def _print_log_event(event: dict[str, Any]) -> None:
+    """Print a single log event with formatting."""
+    message = event.get("message", "").strip()
+
+    if not message:
+        return
+
+    # Dim metadata lines
+    if message.startswith(("REPORT ", "START ", "END ", "XRAY ")):
+        console.print(f"[dim]{message}[/dim]")
+        return
+
+    # Try structured JSON (aws-lambda-powertools format)
+    try:
+        parsed = json.loads(message)
+        level = parsed.get("level", "INFO")
+        color = "red" if level == "ERROR" else "yellow" if level == "WARNING" else "cyan"
+        service = parsed.get("service", "")
+        msg = parsed.get("message", message)
+        timestamp = parsed.get("timestamp", "")
+
+        console.print(
+            f"[dim]{timestamp}[/dim] [{color}]{level}[/{color}] [bold]{service}[/bold] {msg}"
+        )
+        return
+    except (json.JSONDecodeError, TypeError):
+        pass
+
+    # Plain text with color hints
+    if "[ERROR]" in message or "Exception" in message:
+        console.print(f"[red]{message}[/red]")
+    elif "[WARNING]" in message:
+        console.print(f"[yellow]{message}[/yellow]")
+    else:
+        console.print(message)

lambdaforge/renderer.py

@@ -0,0 +1,72 @@
+"""Template renderer — wraps Cookiecutter for project generation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from cookiecutter.main import cookiecutter
+
+
+class TemplateRenderer:
+    """Renders Cookiecutter templates into project directories."""
+
+    def __init__(self, templates_dir: Path | None = None) -> None:
+        if templates_dir is None:
+            # Try multiple locations for bundled templates
+            candidates = [
+                # Installed package: templates/ at same level as lambdaforge/
+                Path(__file__).parent.parent / "templates",
+                # Development mode (pip install -e .): repo_root/templates/
+                Path(__file__).parent.parent.parent / "templates",
+            ]
+            for candidate in candidates:
+                if candidate.exists() and any(candidate.iterdir()):
+                    self.templates_dir = candidate
+                    break
+            else:
+                self.templates_dir = candidates[0]
+        else:
+            self.templates_dir = templates_dir
+
+    def render(
+        self,
+        template_name: str,
+        project_name: str,
+        context: dict,
+        output_dir: str = ".",
+    ) -> Path:
+        """Render a template into a project directory.
+
+        Args:
+            template_name: Name of the template (e.g., "python-api")
+            project_name: Name of the new project
+            context: Variables to pass to the template
+            output_dir: Where to create the project
+
+        Returns:
+            Path to the created project
+
+        Raises:
+            FileNotFoundError: If template doesn't exist
+        """
+        template_path = self.templates_dir / template_name
+        if not template_path.exists():
+            raise FileNotFoundError(f"Template not found: {template_path}")
+
+        # Cookiecutter requires the template to be a git repo or have a specific structure
+        # For simplicity, we use the project_name as the slug
+        slug = project_name.replace("-", "_")
+
+        result_path = cookiecutter(
+            template=str(template_path),
+            no_input=True,
+            extra_context={
+                **context,
+                "project_slug": slug,
+                "project_name": project_name,
+            },
+            output_dir=output_dir,
+            overwrite_if_exists=True,
+        )
+
+        return Path(result_path)