clue2app-cli 0.2.7__py3-none-any.whl

clue2app_cli/wizard.py

@@ -0,0 +1,1079 @@
+#!/usr/bin/env python3
+"""
+Interactive Deploy Wizard with animations for Clue2App CLI.
+
+This module provides a step-by-step wizard experience similar to the console UI,
+with animated transitions and rich visual feedback.
+"""
+
+import time
+import sys
+from typing import Optional, List, Dict, Any, Callable
+from dataclasses import dataclass, field
+
+import questionary
+from questionary import Style
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.live import Live
+from rich.layout import Layout
+from rich.align import Align
+from rich.box import ROUNDED, DOUBLE, HEAVY
+from rich.spinner import Spinner
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+# Custom questionary style matching Clue2App theme
+WIZARD_STYLE = Style([
+    ('qmark', 'fg:#3b82f6 bold'),       # Blue question mark
+    ('question', 'bold'),                # Bold question
+    ('answer', 'fg:#22c55e bold'),       # Green answer
+    ('pointer', 'fg:#3b82f6 bold'),      # Blue pointer
+    ('highlighted', 'fg:#3b82f6 bold'),  # Blue highlighted
+    ('selected', 'fg:#22c55e'),          # Green selected
+    ('separator', 'fg:#64748b'),         # Gray separator
+    ('instruction', 'fg:#94a3b8'),       # Light gray instructions
+    ('text', ''),                        # Default text
+    ('disabled', 'fg:#64748b italic'),   # Disabled option
+])
+
+
+@dataclass
+class WizardStep:
+    """Represents a single step in the wizard."""
+    name: str
+    title: str
+    description: str
+    icon: str = "○"
+    fields: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class WizardState:
+    """Holds the current state of the wizard."""
+    current_step: int = 0
+    total_steps: int = 5
+    data: Dict[str, Any] = field(default_factory=dict)
+    completed_steps: List[int] = field(default_factory=list)
+
+
+class AnimatedStepIndicator:
+    """Renders an animated step indicator like the UI wizard."""
+
+    STEP_ICONS = {
+        'pending': '○',
+        'active': '●',
+        'completed': '✓',
+    }
+
+    COLORS = {
+        'pending': 'dim white',
+        'active': 'bold blue',
+        'completed': 'bold green',
+        'connector_done': 'green',
+        'connector_pending': 'dim white',
+    }
+
+    def __init__(self, steps: List[WizardStep], current: int = 0, completed: List[int] = None):
+        self.steps = steps
+        self.current = current
+        self.completed = completed or []
+
+    def render(self) -> Panel:
+        """Render the step indicator as a Rich Panel."""
+        parts = []
+
+        for i, step in enumerate(self.steps):
+            # Determine step state
+            if i in self.completed:
+                state = 'completed'
+                icon = self.STEP_ICONS['completed']
+                color = self.COLORS['completed']
+            elif i == self.current:
+                state = 'active'
+                icon = self.STEP_ICONS['active']
+                color = self.COLORS['active']
+            else:
+                state = 'pending'
+                icon = self.STEP_ICONS['pending']
+                color = self.COLORS['pending']
+
+            # Build step text
+            step_text = Text()
+            step_text.append(f" {icon} ", style=color)
+            step_text.append(f"{step.name}", style=color if state != 'pending' else 'dim')
+            parts.append(step_text)
+
+            # Add connector (except for last step)
+            if i < len(self.steps) - 1:
+                connector_color = self.COLORS['connector_done'] if i in self.completed else self.COLORS['connector_pending']
+                connector = Text(" ─── ", style=connector_color)
+                parts.append(connector)
+
+        # Combine all parts
+        combined = Text()
+        for part in parts:
+            combined.append(part)
+
+        return Panel(
+            Align.center(combined),
+            border_style="blue",
+            box=ROUNDED,
+            padding=(0, 1),
+        )
+
+
+class DeployWizard:
+    """Interactive deployment wizard with animations."""
+
+    STEPS = [
+        WizardStep(
+            name="Basics",
+            title="Application Basics",
+            description="Give your application a name and select target cluster",
+            icon="📱",
+        ),
+        WizardStep(
+            name="Source",
+            title="Source Code",
+            description="Configure your Git repository",
+            icon="📦",
+        ),
+        WizardStep(
+            name="Registry",
+            title="Container Registry",
+            description="Choose where to store your container images",
+            icon="🐳",
+        ),
+        WizardStep(
+            name="Settings",
+            title="Application Settings",
+            description="Configure deployment, scaling, and environment",
+            icon="⚙️",
+        ),
+        WizardStep(
+            name="Review",
+            title="Review & Deploy",
+            description="Review your configuration and deploy",
+            icon="🚀",
+        ),
+    ]
+
+    def __init__(self, projects: List[Dict] = None):
+        self.state = WizardState(total_steps=len(self.STEPS))
+        self.projects = projects or []
+        self.indicator = AnimatedStepIndicator(self.STEPS)
+
+    def clear_screen(self):
+        """Clear the terminal screen."""
+        console.clear()
+
+    def show_header(self):
+        """Display the wizard header with step indicator."""
+        self.indicator.current = self.state.current_step
+        self.indicator.completed = self.state.completed_steps
+
+        # Title
+        title = Text()
+        title.append("🚀 ", style="bold")
+        title.append("Deploy Application Wizard", style="bold blue")
+
+        console.print()
+        console.print(Align.center(title))
+        console.print()
+        console.print(self.indicator.render())
+        console.print()
+
+    def animate_transition(self, direction: str = "forward"):
+        """Animate the transition between steps."""
+        frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+        with Live(console=console, refresh_per_second=20) as live:
+            for i, frame in enumerate(frames):
+                text = Text()
+                text.append(f"  {frame} ", style="blue")
+                if direction == "forward":
+                    text.append("Loading next step...", style="dim")
+                else:
+                    text.append("Going back...", style="dim")
+                live.update(Align.center(text))
+                time.sleep(0.03)
+
+    def step_basics(self) -> bool:
+        """Step 1: Application basics."""
+        self.clear_screen()
+        self.show_header()
+
+        step = self.STEPS[0]
+        console.print(Panel(
+            f"[bold]{step.icon} {step.title}[/bold]\n[dim]{step.description}[/dim]",
+            border_style="blue",
+            box=ROUNDED,
+        ))
+        console.print()
+
+        # Application name
+        app_name = questionary.text(
+            "Application Name:",
+            instruction="(lowercase, alphanumeric, hyphens allowed)",
+            validate=lambda x: len(x) >= 2 or "Name must be at least 2 characters",
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if app_name is None:  # User cancelled
+            return False
+
+        self.state.data['app_name'] = app_name.lower().replace(' ', '-').replace('_', '-')
+
+        # Project selection (if multiple projects available)
+        if self.projects:
+            project_choices = [
+                questionary.Choice(
+                    title=f"{p.get('name')} ({p.get('ns', 'default')})",
+                    value=p
+                ) for p in self.projects
+            ]
+
+            selected_project = questionary.select(
+                "Select Project:",
+                choices=project_choices,
+                style=WIZARD_STYLE,
+            ).ask()
+
+            if selected_project is None:
+                return False
+
+            self.state.data['project'] = selected_project
+
+        return True
+
+    def step_source(self) -> bool:
+        """Step 2: Source code configuration."""
+        self.clear_screen()
+        self.show_header()
+
+        step = self.STEPS[1]
+        console.print(Panel(
+            f"[bold]{step.icon} {step.title}[/bold]\n[dim]{step.description}[/dim]",
+            border_style="blue",
+            box=ROUNDED,
+        ))
+        console.print()
+
+        # Git URL
+        git_url = questionary.text(
+            "Git Repository URL:",
+            instruction="(e.g., https://github.com/user/repo.git)",
+            validate=lambda x: x.startswith(('http://', 'https://', 'git@')) or "Enter a valid Git URL",
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if git_url is None:
+            return False
+
+        self.state.data['git_url'] = git_url
+
+        # Branch
+        branch = questionary.select(
+            "Git Branch:",
+            choices=[
+                questionary.Choice("main", value="main"),
+                questionary.Choice("master", value="master"),
+                questionary.Choice("Custom...", value="custom"),
+            ],
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if branch is None:
+            return False
+
+        if branch == "custom":
+            branch = questionary.text(
+                "Enter branch name:",
+                style=WIZARD_STYLE,
+            ).ask()
+            if branch is None:
+                return False
+
+        self.state.data['branch'] = branch
+
+        # Private repo?
+        is_private = questionary.confirm(
+            "Is this a private repository?",
+            default=False,
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if is_private is None:
+            return False
+
+        self.state.data['is_private'] = is_private
+
+        if is_private:
+            git_token = questionary.password(
+                "Git Token/Password:",
+                style=WIZARD_STYLE,
+            ).ask()
+
+            if git_token is None:
+                return False
+
+            self.state.data['git_token'] = git_token
+
+        return True
+
+    def step_registry(self) -> bool:
+        """Step 3: Container registry configuration."""
+        self.clear_screen()
+        self.show_header()
+
+        step = self.STEPS[2]
+        console.print(Panel(
+            f"[bold]{step.icon} {step.title}[/bold]\n[dim]{step.description}[/dim]",
+            border_style="blue",
+            box=ROUNDED,
+        ))
+        console.print()
+
+        registry_type = questionary.select(
+            "Container Registry:",
+            choices=[
+                questionary.Choice(
+                    "Platform Registry (Recommended)",
+                    value="PLATFORM_REGISTRY",
+                ),
+                questionary.Choice(
+                    "Private Registry",
+                    value="PRIVATE_REGISTRY",
+                ),
+            ],
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if registry_type is None:
+            return False
+
+        self.state.data['registry_type'] = registry_type
+
+        if registry_type == "PRIVATE_REGISTRY":
+            registry_url = questionary.text(
+                "Registry URL:",
+                instruction="(e.g., docker.io, gcr.io, your-registry.com)",
+                style=WIZARD_STYLE,
+            ).ask()
+
+            if registry_url is None:
+                return False
+
+            self.state.data['registry_url'] = registry_url
+
+            registry_user = questionary.text(
+                "Registry Username:",
+                style=WIZARD_STYLE,
+            ).ask()
+
+            registry_pass = questionary.password(
+                "Registry Password:",
+                style=WIZARD_STYLE,
+            ).ask()
+
+            if registry_user is None or registry_pass is None:
+                return False
+
+            self.state.data['registry_user'] = registry_user
+            self.state.data['registry_pass'] = registry_pass
+
+        return True
+
+    def step_settings(self) -> bool:
+        """Step 4: Application settings."""
+        self.clear_screen()
+        self.show_header()
+
+        step = self.STEPS[3]
+        console.print(Panel(
+            f"[bold]{step.icon} {step.title}[/bold]\n[dim]{step.description}[/dim]",
+            border_style="blue",
+            box=ROUNDED,
+        ))
+        console.print()
+
+        # Container port
+        port = questionary.text(
+            "Container Port:",
+            default="8080",
+            validate=lambda x: x.isdigit() and 1 <= int(x) <= 65535 or "Enter a valid port (1-65535)",
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if port is None:
+            return False
+
+        self.state.data['port'] = int(port)
+
+        # Application size
+        size = questionary.select(
+            "Application Size:",
+            choices=[
+                questionary.Choice("Tiny (256MB RAM, 0.25 CPU)", value="TINY"),
+                questionary.Choice("Small (512MB RAM, 0.5 CPU)", value="SMALL"),
+                questionary.Choice("Medium (1GB RAM, 1 CPU)", value="MEDIUM"),
+                questionary.Choice("Large (2GB RAM, 2 CPU)", value="LARGE"),
+            ],
+            default="SMALL",
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if size is None:
+            return False
+
+        self.state.data['size'] = size
+
+        # Deploy automatically?
+        auto_deploy = questionary.confirm(
+            "Deploy automatically after build?",
+            default=True,
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if auto_deploy is None:
+            return False
+
+        self.state.data['auto_deploy'] = auto_deploy
+
+        # Scale to zero?
+        scale_to_zero = questionary.confirm(
+            "Enable scale to zero? (saves resources when idle)",
+            default=False,
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if scale_to_zero is None:
+            return False
+
+        self.state.data['scale_to_zero'] = scale_to_zero
+
+        # Environment variables
+        add_env = questionary.confirm(
+            "Add environment variables?",
+            default=False,
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if add_env:
+            env_vars = {}
+            while True:
+                env_input = questionary.text(
+                    "Environment variable (KEY=VALUE, or empty to finish):",
+                    style=WIZARD_STYLE,
+                ).ask()
+
+                if not env_input:
+                    break
+
+                if '=' in env_input:
+                    key, value = env_input.split('=', 1)
+                    env_vars[key.strip()] = value.strip()
+                    console.print(f"  [green]✓[/green] Added: {key.strip()}")
+
+            self.state.data['env_vars'] = env_vars
+
+        return True
+
+    def step_review(self) -> bool:
+        """Step 5: Review and deploy."""
+        self.clear_screen()
+        self.show_header()
+
+        step = self.STEPS[4]
+        console.print(Panel(
+            f"[bold]{step.icon} {step.title}[/bold]\n[dim]{step.description}[/dim]",
+            border_style="blue",
+            box=ROUNDED,
+        ))
+        console.print()
+
+        # Build review table
+        table = Table(
+            show_header=False,
+            box=ROUNDED,
+            border_style="blue",
+            padding=(0, 2),
+            expand=True,
+        )
+        table.add_column("Property", style="cyan", width=20)
+        table.add_column("Value", style="white")
+
+        # Basic Info section
+        table.add_row("[bold]BASIC INFO[/bold]", "")
+        table.add_row("Application Name", self.state.data.get('app_name', 'N/A'))
+        if 'project' in self.state.data:
+            project = self.state.data['project']
+            table.add_row("Project", f"{project.get('name')} ({project.get('ns')})")
+
+        # Source Code section
+        table.add_row("", "")
+        table.add_row("[bold]SOURCE CODE[/bold]", "")
+        table.add_row("Git Repository", self.state.data.get('git_url', 'N/A'))
+        table.add_row("Branch", self.state.data.get('branch', 'main'))
+        table.add_row("Access", "[yellow]Private[/yellow]" if self.state.data.get('is_private') else "[green]Public[/green]")
+
+        # Registry section
+        table.add_row("", "")
+        table.add_row("[bold]CONTAINER REGISTRY[/bold]", "")
+        registry = self.state.data.get('registry_type', 'PLATFORM_REGISTRY')
+        if registry == 'PLATFORM_REGISTRY':
+            table.add_row("Registry", "[green]Platform Registry[/green]")
+        else:
+            table.add_row("Registry", self.state.data.get('registry_url', 'N/A'))
+
+        # Settings section
+        table.add_row("", "")
+        table.add_row("[bold]SETTINGS[/bold]", "")
+        table.add_row("Container Port", str(self.state.data.get('port', 8080)))
+        table.add_row("Application Size", self.state.data.get('size', 'SMALL'))
+        table.add_row("Auto Deploy", "[green]Yes[/green]" if self.state.data.get('auto_deploy', True) else "[yellow]No[/yellow]")
+        table.add_row("Scale to Zero", "[green]Yes[/green]" if self.state.data.get('scale_to_zero') else "[dim]No[/dim]")
+
+        # Environment variables
+        env_vars = self.state.data.get('env_vars', {})
+        if env_vars:
+            table.add_row("", "")
+            table.add_row("[bold]ENVIRONMENT[/bold]", "")
+            for key, value in env_vars.items():
+                # Mask sensitive values
+                display_value = value if len(value) <= 20 else value[:17] + "..."
+                table.add_row(f"  {key}", display_value)
+
+        console.print(table)
+        console.print()
+
+        # Confirm deployment
+        action = questionary.select(
+            "What would you like to do?",
+            choices=[
+                questionary.Choice("🚀 Deploy Application", value="deploy"),
+                questionary.Choice("✏️  Edit Configuration", value="edit"),
+                questionary.Choice("❌ Cancel", value="cancel"),
+            ],
+            style=WIZARD_STYLE,
+        ).ask()
+
+        if action == "deploy":
+            self.state.data['confirmed'] = True
+            return True
+        elif action == "edit":
+            # Go back to first step
+            self.state.current_step = 0
+            self.state.completed_steps = []
+            return self.run_wizard()
+        else:
+            return False
+
+    def run_wizard(self) -> Optional[Dict[str, Any]]:
+        """Run the complete wizard flow."""
+        step_functions = [
+            self.step_basics,
+            self.step_source,
+            self.step_registry,
+            self.step_settings,
+            self.step_review,
+        ]
+
+        while self.state.current_step < len(step_functions):
+            step_func = step_functions[self.state.current_step]
+
+            # Run the step
+            result = step_func()
+
+            if result:
+                # Mark step as completed and move to next
+                if self.state.current_step not in self.state.completed_steps:
+                    self.state.completed_steps.append(self.state.current_step)
+
+                self.state.current_step += 1
+
+                # Animate transition (except after last step)
+                if self.state.current_step < len(step_functions):
+                    self.animate_transition("forward")
+            else:
+                # User cancelled or went back
+                if self.state.current_step > 0:
+                    # Ask if they want to go back
+                    go_back = questionary.confirm(
+                        "Go back to previous step?",
+                        default=True,
+                        style=WIZARD_STYLE,
+                    ).ask()
+
+                    if go_back:
+                        self.state.current_step -= 1
+                        self.animate_transition("backward")
+                    else:
+                        # Cancel wizard
+                        return None
+                else:
+                    # Cancel wizard from first step
+                    return None
+
+        # Wizard completed
+        if self.state.data.get('confirmed'):
+            return self.state.data
+
+        return None
+
+    def show_deployment_progress(self, deploy_func: Callable) -> bool:
+        """Show animated deployment progress."""
+        self.clear_screen()
+
+        console.print()
+        console.print(Align.center(Text("🚀 Deploying Application", style="bold blue")))
+        console.print()
+
+        stages = [
+            ("Validating configuration...", 0.5),
+            ("Creating application...", 1.0),
+            ("Setting up Git source...", 0.8),
+            ("Configuring registry...", 0.5),
+            ("Initiating build...", 1.5),
+            ("Finalizing deployment...", 0.5),
+        ]
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+
+            for stage_text, duration in stages:
+                task = progress.add_task(stage_text, total=None)
+                time.sleep(duration)
+                progress.update(task, description=f"[green]✓[/green] {stage_text}")
+                progress.stop_task(task)
+
+        # Actually deploy
+        console.print()
+        try:
+            result = deploy_func(self.state.data)
+
+            console.print()
+            console.print(Panel(
+                "[bold green]✓ Deployment Initiated Successfully![/bold green]\n\n"
+                f"[dim]Application:[/dim] [bold]{self.state.data.get('app_name')}[/bold]\n"
+                f"[dim]Status:[/dim] Building\n\n"
+                "[dim]Next steps:[/dim]\n"
+                "  • Run [bold]c2a builds list[/bold] to monitor build progress\n"
+                "  • Run [bold]c2a services list[/bold] to see running services",
+                border_style="green",
+                box=DOUBLE,
+            ))
+
+            return True
+
+        except Exception as e:
+            console.print()
+            console.print(Panel(
+                f"[bold red]✗ Deployment Failed[/bold red]\n\n"
+                f"[red]{str(e)}[/red]",
+                border_style="red",
+                box=DOUBLE,
+            ))
+            return False
+
+
+class LiveBuildMonitor:
+    """Real-time build progress monitor with animations."""
+
+    BUILD_PHASES = [
+        ("PREPARE", "Preparing build environment"),
+        ("DETECT", "Detecting buildpacks"),
+        ("ANALYZE", "Analyzing source code"),
+        ("RESTORE", "Restoring cached layers"),
+        ("BUILD", "Building application"),
+        ("EXPORT", "Exporting container image"),
+        ("CACHE", "Caching layers"),
+        ("COMPLETION", "Completing build"),
+    ]
+
+    PHASE_ICONS = {
+        "pending": "○",
+        "running": "◉",
+        "completed": "✓",
+        "failed": "✗",
+    }
+
+    def __init__(self, app_name: str, namespace: str = None):
+        self.app_name = app_name
+        self.namespace = namespace
+        self.current_phase = 0
+        self.build_status = "BUILDING"
+        self.logs: List[str] = []
+        self.start_time = time.time()
+
+    def render_progress(self) -> Panel:
+        """Render the current build progress."""
+        # Header
+        elapsed = int(time.time() - self.start_time)
+        elapsed_str = f"{elapsed // 60}m {elapsed % 60}s"
+
+        header = Text()
+        header.append("🔨 ", style="bold")
+        header.append("Building: ", style="bold blue")
+        header.append(self.app_name, style="bold cyan")
+        header.append(f"  [dim]({elapsed_str})[/dim]")
+
+        # Phase progress
+        phases_text = Text()
+        for i, (phase_name, phase_desc) in enumerate(self.BUILD_PHASES):
+            if i < self.current_phase:
+                icon = self.PHASE_ICONS["completed"]
+                style = "green"
+            elif i == self.current_phase:
+                icon = self.PHASE_ICONS["running"]
+                style = "blue bold"
+            else:
+                icon = self.PHASE_ICONS["pending"]
+                style = "dim"
+
+            phases_text.append(f"\n  {icon} ", style=style)
+            phases_text.append(f"{phase_name}: ", style=style)
+            phases_text.append(phase_desc, style="dim" if style == "dim" else "")
+
+        # Recent logs
+        logs_text = Text()
+        if self.logs:
+            logs_text.append("\n\n[dim]Recent logs:[/dim]\n")
+            for log in self.logs[-5:]:  # Show last 5 log lines
+                logs_text.append(f"  [dim]{log[:80]}[/dim]\n")
+
+        # Status bar
+        status_text = Text()
+        if self.build_status == "BUILDING":
+            status_text.append("\n[blue]● Building...[/blue]")
+        elif self.build_status == "SUCCESS":
+            status_text.append("\n[green]✓ Build completed successfully![/green]")
+        elif self.build_status == "FAILED":
+            status_text.append("\n[red]✗ Build failed[/red]")
+
+        content = Group(header, phases_text, logs_text, status_text)
+
+        return Panel(
+            content,
+            border_style="blue" if self.build_status == "BUILDING" else ("green" if self.build_status == "SUCCESS" else "red"),
+            box=ROUNDED,
+            title="[bold]Build Progress[/bold]",
+            subtitle="[dim]Press Ctrl+C to run in background[/dim]",
+        )
+
+    def update_from_status(self, status: Dict[str, Any]):
+        """Update monitor state from API status response."""
+        conditions = status.get('conditions', [])
+
+        for cond in conditions:
+            if cond.get('type') == 'Ready':
+                if cond.get('status') == 'True':
+                    self.build_status = "SUCCESS"
+                    self.current_phase = len(self.BUILD_PHASES)
+                elif cond.get('reason') == 'BuildFailed':
+                    self.build_status = "FAILED"
+                break
+
+        # Try to determine phase from latest build reason
+        reason = status.get('latestBuildReason', '')
+        if 'CONFIG' in reason or 'TRIGGER' in reason:
+            self.current_phase = min(1, self.current_phase)
+        elif 'STACK' in reason:
+            self.current_phase = min(2, self.current_phase)
+        elif 'BUILDPACK' in reason:
+            self.current_phase = min(4, self.current_phase)
+
+    def add_log(self, log_line: str):
+        """Add a log line to the display."""
+        self.logs.append(log_line)
+        if len(self.logs) > 100:  # Keep last 100 lines
+            self.logs = self.logs[-100:]
+
+
+class LiveServiceMonitor:
+    """Real-time service deployment monitor."""
+
+    SERVICE_STATES = [
+        ("PENDING", "Service pending"),
+        ("CREATING", "Creating pods"),
+        ("CONFIGURING", "Configuring networking"),
+        ("SCALING", "Scaling replicas"),
+        ("READY", "Service ready"),
+    ]
+
+    def __init__(self, service_name: str, namespace: str = None):
+        self.service_name = service_name
+        self.namespace = namespace
+        self.current_state = 0
+        self.status = "DEPLOYING"
+        self.url: Optional[str] = None
+        self.pods: int = 0
+        self.ready_pods: int = 0
+        self.start_time = time.time()
+
+    def render_progress(self) -> Panel:
+        """Render the current service deployment progress."""
+        elapsed = int(time.time() - self.start_time)
+        elapsed_str = f"{elapsed // 60}m {elapsed % 60}s"
+
+        # Header
+        header = Text()
+        header.append("🚀 ", style="bold")
+        header.append("Deploying: ", style="bold blue")
+        header.append(self.service_name, style="bold cyan")
+        header.append(f"  [dim]({elapsed_str})[/dim]")
+
+        # State progress
+        states_text = Text()
+        for i, (state_name, state_desc) in enumerate(self.SERVICE_STATES):
+            if i < self.current_state:
+                icon = "✓"
+                style = "green"
+            elif i == self.current_state:
+                icon = "◉"
+                style = "blue bold"
+            else:
+                icon = "○"
+                style = "dim"
+
+            states_text.append(f"\n  {icon} ", style=style)
+            states_text.append(f"{state_name}: ", style=style)
+            states_text.append(state_desc, style="dim" if style == "dim" else "")
+
+        # Pod status
+        pod_text = Text()
+        pod_text.append(f"\n\n  Pods: ")
+        if self.pods > 0:
+            pod_text.append(f"[green]{self.ready_pods}[/green]/{self.pods} ready")
+        else:
+            pod_text.append("[dim]waiting...[/dim]")
+
+        # URL
+        url_text = Text()
+        if self.url:
+            url_text.append(f"\n  URL: [blue]{self.url}[/blue]")
+
+        # Status
+        status_text = Text()
+        if self.status == "DEPLOYING":
+            status_text.append("\n\n[blue]● Deploying...[/blue]")
+        elif self.status == "READY":
+            status_text.append("\n\n[green]✓ Service is ready![/green]")
+        elif self.status == "FAILED":
+            status_text.append("\n\n[red]✗ Deployment failed[/red]")
+
+        content = Group(header, states_text, pod_text, url_text, status_text)
+
+        border_color = "blue" if self.status == "DEPLOYING" else ("green" if self.status == "READY" else "red")
+
+        return Panel(
+            content,
+            border_style=border_color,
+            box=ROUNDED,
+            title="[bold]Service Deployment[/bold]",
+            subtitle="[dim]Press Ctrl+C to run in background[/dim]",
+        )
+
+    def update_from_status(self, status: Dict[str, Any]):
+        """Update from Knative service status."""
+        conditions = status.get('conditions', [])
+
+        # Check Ready condition
+        for cond in conditions:
+            if cond.get('type') == 'Ready':
+                if cond.get('status') == 'True':
+                    self.status = "READY"
+                    self.current_state = len(self.SERVICE_STATES)
+                elif cond.get('status') == 'False':
+                    reason = cond.get('reason', '')
+                    if 'Failed' in reason or 'Error' in reason:
+                        self.status = "FAILED"
+                break
+
+        # Get URL
+        self.url = status.get('url')
+
+        # Estimate state from conditions
+        ready_count = sum(1 for c in conditions if c.get('status') == 'True')
+        self.current_state = min(ready_count, len(self.SERVICE_STATES) - 1)
+
+
+def monitor_build_live(
+    sdk_client,
+    image_name: str,
+    namespace: str,
+    timeout: int = 600,
+    poll_interval: float = 2.0
+) -> bool:
+    """
+    Monitor a build in real-time with live updates.
+
+    Args:
+        sdk_client: The SDK client for API calls
+        image_name: Name of the image being built
+        namespace: Kubernetes namespace
+        timeout: Maximum time to wait (seconds)
+        poll_interval: Time between status checks
+
+    Returns:
+        True if build succeeded, False otherwise
+    """
+    monitor = LiveBuildMonitor(image_name, namespace)
+    start_time = time.time()
+
+    with Live(monitor.render_progress(), console=console, refresh_per_second=4) as live:
+        while time.time() - start_time < timeout:
+            try:
+                # Get image status
+                images = sdk_client.apps.get_images(namespace=namespace)
+                image = next((img for img in images if image_name in img.get('metadata', {}).get('name', '')), None)
+
+                if image:
+                    monitor.update_from_status(image.get('status', {}))
+
+                    # Simulate phase progress based on time for demo
+                    elapsed = time.time() - start_time
+                    if monitor.build_status == "BUILDING":
+                        monitor.current_phase = min(int(elapsed / 10), len(monitor.BUILD_PHASES) - 1)
+
+                live.update(monitor.render_progress())
+
+                if monitor.build_status in ("SUCCESS", "FAILED"):
+                    time.sleep(1)  # Brief pause to show final state
+                    break
+
+                time.sleep(poll_interval)
+
+            except KeyboardInterrupt:
+                console.print("\n[yellow]Continuing in background...[/yellow]")
+                console.print(f"  Run [bold]c2a builds logs {image_name}[/bold] to view logs")
+                return True
+
+            except Exception as e:
+                monitor.add_log(f"Error: {str(e)}")
+                live.update(monitor.render_progress())
+                time.sleep(poll_interval)
+
+    return monitor.build_status == "SUCCESS"
+
+
+def monitor_service_live(
+    sdk_client,
+    service_name: str,
+    namespace: str,
+    timeout: int = 300,
+    poll_interval: float = 2.0
+) -> bool:
+    """
+    Monitor a service deployment in real-time.
+
+    Args:
+        sdk_client: The SDK client for API calls
+        service_name: Name of the service
+        namespace: Kubernetes namespace
+        timeout: Maximum time to wait
+        poll_interval: Time between checks
+
+    Returns:
+        True if deployment succeeded, False otherwise
+    """
+    monitor = LiveServiceMonitor(service_name, namespace)
+    start_time = time.time()
+
+    with Live(monitor.render_progress(), console=console, refresh_per_second=4) as live:
+        while time.time() - start_time < timeout:
+            try:
+                # In a real implementation, this would call the service status API
+                # For now, simulate progress
+                elapsed = time.time() - start_time
+
+                if elapsed > 5:
+                    monitor.pods = 1
+                if elapsed > 10:
+                    monitor.ready_pods = 1
+                if elapsed > 15:
+                    monitor.url = f"https://{service_name}.{namespace}.apps.clue2.app"
+                if elapsed > 20:
+                    monitor.status = "READY"
+                    monitor.current_state = len(monitor.SERVICE_STATES)
+
+                live.update(monitor.render_progress())
+
+                if monitor.status in ("READY", "FAILED"):
+                    time.sleep(1)
+                    break
+
+                time.sleep(poll_interval)
+
+            except KeyboardInterrupt:
+                console.print("\n[yellow]Continuing in background...[/yellow]")
+                console.print(f"  Run [bold]c2a services logs {service_name}[/bold] to view logs")
+                return True
+
+            except Exception as e:
+                live.update(monitor.render_progress())
+                time.sleep(poll_interval)
+
+    return monitor.status == "READY"
+
+
+def run_deploy_wizard(projects: List[Dict] = None, deploy_func: Callable = None, sdk_client=None) -> Optional[Dict[str, Any]]:
+    """
+    Run the interactive deploy wizard.
+
+    Args:
+        projects: List of available projects
+        deploy_func: Function to call for actual deployment
+        sdk_client: SDK client for live monitoring
+
+    Returns:
+        Wizard data if completed, None if cancelled
+    """
+    wizard = DeployWizard(projects=projects)
+
+    try:
+        result = wizard.run_wizard()
+
+        if result and deploy_func:
+            # Show initial deployment progress
+            success = wizard.show_deployment_progress(deploy_func)
+
+            if success and sdk_client:
+                # Monitor build progress
+                app_name = result.get('app_name')
+                namespace = result.get('project', {}).get('ns', 'default')
+
+                console.print()
+                console.print("[bold]Monitoring build progress...[/bold]")
+                console.print("[dim]Press Ctrl+C to run in background[/dim]")
+                console.print()
+
+                build_success = monitor_build_live(
+                    sdk_client,
+                    f"{app_name}-image",
+                    namespace,
+                )
+
+                if build_success and result.get('auto_deploy', True):
+                    console.print()
+                    console.print("[bold]Monitoring service deployment...[/bold]")
+                    console.print()
+
+                    monitor_service_live(
+                        sdk_client,
+                        app_name,
+                        namespace,
+                    )
+
+        return result
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Wizard cancelled.[/yellow]")
+        return None