clue2app-cli 0.2.7__py3-none-any.whl

clue2app_cli/curses_wizard.py

@@ -0,0 +1,839 @@
+#!/usr/bin/env python3
+"""
+Ncurses-based Deploy Wizard for Clue2App CLI.
+
+A simple, traditional terminal UI using Python's curses library.
+"""
+
+import curses
+import time
+from typing import Optional, List, Dict, Any, Callable
+from dataclasses import dataclass, field
+
+
+@dataclass
+class WizardField:
+    """A form field in the wizard."""
+    name: str
+    label: str
+    field_type: str = "text"  # text, password, select, checkbox
+    options: List[str] = field(default_factory=list)
+    default: str = ""
+    required: bool = False
+    value: str = ""
+
+
+@dataclass
+class WizardStep:
+    """A step in the wizard."""
+    name: str
+    title: str
+    description: str
+    fields: List[WizardField] = field(default_factory=list)
+
+
+class CursesWizard:
+    """Ncurses-based deploy wizard with animations."""
+
+    # Spinner animation frames
+    SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+    # Colors
+    COLOR_TITLE = 1
+    COLOR_ACTIVE = 2
+    COLOR_COMPLETED = 3
+    COLOR_PENDING = 4
+    COLOR_INPUT = 5
+    COLOR_ERROR = 6
+    COLOR_SUCCESS = 7
+
+    # Build phases for progress display
+    BUILD_PHASES = [
+        ("FETCHING", "Fetching source code"),
+        ("DETECTING", "Detecting buildpack"),
+        ("ANALYZING", "Analyzing dependencies"),
+        ("BUILDING", "Building application"),
+        ("EXPORTING", "Exporting image"),
+    ]
+
+    # Service deployment states
+    SERVICE_STATES = [
+        ("PENDING", "Service pending"),
+        ("CREATING", "Creating pods"),
+        ("CONFIGURING", "Configuring networking"),
+        ("SCALING", "Scaling replicas"),
+        ("READY", "Service ready"),
+    ]
+
+    STEPS = [
+        WizardStep(
+            name="basics",
+            title="Application Basics",
+            description="Enter your application name",
+            fields=[
+                WizardField("app_name", "Application Name", required=True),
+            ]
+        ),
+        WizardStep(
+            name="source",
+            title="Source Code",
+            description="Configure your Git repository",
+            fields=[
+                WizardField("git_url", "Git Repository URL", required=True),
+                WizardField("branch", "Branch", default="main"),
+                WizardField("is_private", "Private Repository?", field_type="checkbox"),
+                WizardField("git_token", "Git Token (for private repos)", field_type="password"),
+            ]
+        ),
+        WizardStep(
+            name="registry",
+            title="Container Registry",
+            description="Choose where to store container images",
+            fields=[
+                WizardField("registry_type", "Registry Type", field_type="select",
+                           options=["Platform Registry", "Private Registry"],
+                           default="Platform Registry"),
+                WizardField("registry_url", "Registry URL (for private)"),
+                WizardField("registry_user", "Registry Username"),
+                WizardField("registry_pass", "Registry Password", field_type="password"),
+            ]
+        ),
+        WizardStep(
+            name="settings",
+            title="Application Settings",
+            description="Configure deployment settings",
+            fields=[
+                WizardField("port", "Container Port", default="8080"),
+                WizardField("size", "Application Size", field_type="select",
+                           options=["TINY", "SMALL", "MEDIUM", "LARGE"],
+                           default="SMALL"),
+                WizardField("auto_deploy", "Auto Deploy?", field_type="checkbox", default="yes"),
+                WizardField("scale_to_zero", "Scale to Zero?", field_type="checkbox", default="no"),
+            ]
+        ),
+        WizardStep(
+            name="review",
+            title="Review & Deploy",
+            description="Review your configuration",
+            fields=[]
+        ),
+    ]
+
+    def __init__(self, projects: List[Dict] = None, deploy_func: Callable = None, sdk_client=None):
+        self.projects = projects or []
+        self.deploy_func = deploy_func
+        self.sdk_client = sdk_client
+        self.current_step = 0
+        self.current_field = 0
+        self.data: Dict[str, Any] = {}
+        self.stdscr = None
+        self.spinner_frame = 0
+        self.has_colors = False
+        # Deployment state
+        self.deploy_status = "IDLE"  # IDLE, BUILDING, DEPLOYING, SUCCESS, FAILED
+        self.build_phase = 0
+        self.service_state = 0
+        self.deploy_start_time = 0
+        self.app_url: Optional[str] = None
+        self.error_message: Optional[str] = None
+        # Dynamically add project selection if multiple projects
+        if len(self.projects) > 1:
+            project_options = [f"{p.get('name')} ({p.get('ns', 'default')})" for p in self.projects]
+            # Insert project field after app_name in basics step
+            basics_step = self.STEPS[0]
+            basics_step.fields.append(
+                WizardField("project", "Target Project", field_type="select",
+                           options=project_options, default=project_options[0] if project_options else None)
+            )
+
+    def init_colors(self):
+        """Initialize color pairs if terminal supports colors."""
+        if curses.has_colors():
+            self.has_colors = True
+            curses.start_color()
+            curses.use_default_colors()
+            curses.init_pair(self.COLOR_TITLE, curses.COLOR_CYAN, -1)
+            curses.init_pair(self.COLOR_ACTIVE, curses.COLOR_BLUE, -1)
+            curses.init_pair(self.COLOR_COMPLETED, curses.COLOR_GREEN, -1)
+            curses.init_pair(self.COLOR_PENDING, curses.COLOR_WHITE, -1)
+            curses.init_pair(self.COLOR_INPUT, curses.COLOR_YELLOW, -1)
+            curses.init_pair(self.COLOR_ERROR, curses.COLOR_RED, -1)
+            curses.init_pair(self.COLOR_SUCCESS, curses.COLOR_GREEN, -1)
+
+    def draw_header(self):
+        """Draw the header with step indicator and colors."""
+        h, w = self.stdscr.getmaxyx()
+
+        # Animated spinner
+        spinner = self.SPINNER[self.spinner_frame % len(self.SPINNER)]
+        self.spinner_frame += 1
+
+        # Title with color
+        title = f" {spinner} Deploy Application Wizard {spinner} "
+        if self.has_colors:
+            self.stdscr.attron(curses.color_pair(self.COLOR_TITLE) | curses.A_BOLD)
+        else:
+            self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(0, (w - len(title)) // 2, title)
+        if self.has_colors:
+            self.stdscr.attroff(curses.color_pair(self.COLOR_TITLE) | curses.A_BOLD)
+        else:
+            self.stdscr.attroff(curses.A_BOLD)
+
+        # Step indicator with colors
+        x = 2
+        for i, step in enumerate(self.STEPS):
+            if i < self.current_step:
+                marker = "✓"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+            elif i == self.current_step:
+                marker = "●"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+            else:
+                marker = "○"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_PENDING))
+
+            step_text = f" {marker} {step.name.capitalize()} "
+            if x + len(step_text) < w:
+                self.stdscr.addstr(2, x, step_text)
+            x += len(step_text)
+
+            # Reset color
+            if self.has_colors:
+                self.stdscr.attroff(curses.color_pair(self.COLOR_COMPLETED))
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+                self.stdscr.attroff(curses.color_pair(self.COLOR_PENDING))
+
+            # Connector
+            if i < len(self.STEPS) - 1 and x + 3 < w:
+                connector = "──"
+                if i < self.current_step and self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+                self.stdscr.addstr(2, x, connector)
+                if i < self.current_step and self.has_colors:
+                    self.stdscr.attroff(curses.color_pair(self.COLOR_COMPLETED))
+                x += len(connector)
+
+        # Horizontal line
+        self.stdscr.addstr(3, 0, "─" * (w - 1))
+
+    def draw_step(self):
+        """Draw the current step content."""
+        h, w = self.stdscr.getmaxyx()
+        step = self.STEPS[self.current_step]
+
+        # Step title
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(5, 2, f"Step {self.current_step + 1}: {step.title}")
+        self.stdscr.attroff(curses.A_BOLD)
+
+        # Description
+        self.stdscr.addstr(6, 2, step.description)
+
+        # Fields
+        if step.name == "review":
+            self.draw_review()
+        else:
+            self.draw_fields(step)
+
+    def draw_fields(self, step: WizardStep):
+        """Draw form fields for a step."""
+        h, w = self.stdscr.getmaxyx()
+        y = 8
+
+        for i, field in enumerate(step.fields):
+            # Highlight current field
+            if i == self.current_field:
+                self.stdscr.attron(curses.A_REVERSE)
+
+            label = f"  {field.label}: "
+            self.stdscr.addstr(y, 2, label)
+
+            if i == self.current_field:
+                self.stdscr.attroff(curses.A_REVERSE)
+
+            # Field value
+            if field.field_type == "checkbox":
+                value = "[X]" if field.value in ["yes", "true", True] else "[ ]"
+            elif field.field_type == "select":
+                value = f"< {field.value or field.default} >"
+            else:
+                value = field.value or field.default or "_" * 20
+
+            self.stdscr.addstr(y, 2 + len(label), value[:w - len(label) - 5])
+            y += 2
+
+    def draw_review(self):
+        """Draw the review screen."""
+        h, w = self.stdscr.getmaxyx()
+        y = 8
+
+        # Build source code section
+        source_items = [
+            ("Git Repository", self.data.get("git_url", "N/A")),
+            ("Branch", self.data.get("branch", "main")),
+            ("Private", "Yes" if self.data.get("is_private") else "No"),
+        ]
+        if self.data.get("is_private") and self.data.get("git_token"):
+            source_items.append(("Git Token", "********"))
+
+        # Build registry section
+        registry_items = [
+            ("Type", self.data.get("registry_type", "Platform Registry")),
+        ]
+        if self.data.get("registry_type") == "Private Registry":
+            if self.data.get("registry_url"):
+                registry_items.append(("Registry URL", self.data.get("registry_url")))
+            if self.data.get("registry_user"):
+                registry_items.append(("Username", self.data.get("registry_user")))
+            if self.data.get("registry_pass"):
+                registry_items.append(("Password", "********"))
+
+        # Build basic info section
+        basic_items = [("Application Name", self.data.get("app_name", "N/A"))]
+        if self.data.get("project"):
+            basic_items.append(("Project", self.data.get("project")))
+
+        sections = [
+            ("BASIC INFO", basic_items),
+            ("SOURCE CODE", source_items),
+            ("REGISTRY", registry_items),
+            ("SETTINGS", [
+                ("Port", self.data.get("port", "8080")),
+                ("Size", self.data.get("size", "SMALL")),
+                ("Auto Deploy", "Yes" if self.data.get("auto_deploy") else "No"),
+                ("Scale to Zero", "Yes" if self.data.get("scale_to_zero") else "No"),
+            ]),
+        ]
+
+        for section_title, items in sections:
+            self.stdscr.attron(curses.A_BOLD)
+            self.stdscr.addstr(y, 2, section_title)
+            self.stdscr.attroff(curses.A_BOLD)
+            y += 1
+
+            for label, value in items:
+                value_str = str(value)
+                # For long values like URLs, show on next line if needed
+                if len(f"{label}: {value_str}") > w - 6 and len(value_str) > 30:
+                    self.stdscr.addstr(y, 4, f"{label}:")
+                    y += 1
+                    # Truncate long URLs but show more of them
+                    self.stdscr.addstr(y, 6, value_str[:w-8])
+                else:
+                    self.stdscr.addstr(y, 4, f"{label}: {value_str}"[:w-6])
+                y += 1
+            y += 1
+
+    def draw_footer(self):
+        """Draw the footer with controls."""
+        h, w = self.stdscr.getmaxyx()
+
+        # Horizontal line
+        self.stdscr.addstr(h - 3, 0, "─" * (w - 1))
+
+        # Controls
+        if self.current_step == len(self.STEPS) - 1:
+            controls = "[Enter] Deploy  [←] Back  [q] Cancel"
+        else:
+            controls = "[Enter] Next  [←] Back  [Tab] Next Field  [q] Cancel"
+
+        self.stdscr.addstr(h - 2, (w - len(controls)) // 2, controls)
+
+    def collect_step_data(self):
+        """Collect data from current step."""
+        step = self.STEPS[self.current_step]
+        for field in step.fields:
+            if field.field_type == "checkbox":
+                self.data[field.name] = field.value in ["yes", "true", True]
+            else:
+                self.data[field.name] = field.value or field.default
+
+    def handle_input(self, key):
+        """Handle keyboard input."""
+        step = self.STEPS[self.current_step]
+
+        if key == ord('q'):
+            return False  # Quit
+
+        elif key == curses.KEY_LEFT or key == ord('b'):
+            # Go back
+            if self.current_step > 0:
+                self.collect_step_data()
+                self.current_step -= 1
+                self.current_field = 0
+
+        elif key == ord('\n') or key == curses.KEY_RIGHT:
+            # Next step or submit
+            self.collect_step_data()
+            if self.current_step < len(self.STEPS) - 1:
+                self.current_step += 1
+                self.current_field = 0
+            else:
+                # Deploy
+                self.data['confirmed'] = True
+                return False
+
+        elif key == ord('\t') or key == curses.KEY_DOWN:
+            # Next field
+            if step.fields and self.current_field < len(step.fields) - 1:
+                self.current_field += 1
+
+        elif key == curses.KEY_UP:
+            # Previous field
+            if self.current_field > 0:
+                self.current_field -= 1
+
+        elif key == ord(' '):
+            # Toggle checkbox or cycle select
+            if step.fields:
+                field = step.fields[self.current_field]
+                if field.field_type == "checkbox":
+                    field.value = "" if field.value else "yes"
+                elif field.field_type == "select":
+                    idx = field.options.index(field.value or field.default) if (field.value or field.default) in field.options else 0
+                    field.value = field.options[(idx + 1) % len(field.options)]
+
+        elif key == curses.KEY_BACKSPACE or key == 127:
+            # Delete character
+            if step.fields:
+                field = step.fields[self.current_field]
+                if field.field_type == "text":
+                    field.value = field.value[:-1]
+
+        elif 32 <= key <= 126:
+            # Regular character input
+            if step.fields:
+                field = step.fields[self.current_field]
+                if field.field_type == "text":
+                    field.value += chr(key)
+
+        return True
+
+    def draw_deployment_header(self):
+        """Draw header for deployment progress screen."""
+        h, w = self.stdscr.getmaxyx()
+
+        # Animated spinner
+        spinner = self.SPINNER[self.spinner_frame % len(self.SPINNER)]
+        self.spinner_frame += 1
+
+        # Title based on status
+        if self.deploy_status == "BUILDING":
+            title = f" {spinner} Building Application {spinner} "
+            color = self.COLOR_ACTIVE
+        elif self.deploy_status == "DEPLOYING":
+            title = f" {spinner} Deploying Service {spinner} "
+            color = self.COLOR_ACTIVE
+        elif self.deploy_status == "SUCCESS":
+            title = " ✓ Deployment Complete! "
+            color = self.COLOR_SUCCESS
+        elif self.deploy_status == "FAILED":
+            title = " ✗ Deployment Failed "
+            color = self.COLOR_ERROR
+        else:
+            title = " Deployment "
+            color = self.COLOR_TITLE
+
+        if self.has_colors:
+            self.stdscr.attron(curses.color_pair(color) | curses.A_BOLD)
+        else:
+            self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(0, (w - len(title)) // 2, title)
+        if self.has_colors:
+            self.stdscr.attroff(curses.color_pair(color) | curses.A_BOLD)
+        else:
+            self.stdscr.attroff(curses.A_BOLD)
+
+        # Horizontal line
+        self.stdscr.addstr(1, 0, "─" * (w - 1))
+
+    def draw_deployment_progress(self):
+        """Draw the deployment progress display."""
+        h, w = self.stdscr.getmaxyx()
+        y = 3
+
+        # Elapsed time
+        elapsed = int(time.time() - self.deploy_start_time)
+        elapsed_str = f"{elapsed // 60}m {elapsed % 60}s"
+
+        app_name = self.data.get('app_name', 'app')
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(y, 2, f"Application: {app_name}")
+        self.stdscr.attroff(curses.A_BOLD)
+        self.stdscr.addstr(y, w - len(elapsed_str) - 4, f"[{elapsed_str}]")
+        y += 2
+
+        # Build progress section
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(y, 2, "BUILD PROGRESS")
+        self.stdscr.attroff(curses.A_BOLD)
+        y += 1
+
+        for i, (phase_name, phase_desc) in enumerate(self.BUILD_PHASES):
+            if self.deploy_status in ("DEPLOYING", "SUCCESS"):
+                # All build phases complete
+                marker = "✓"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+            elif self.deploy_status == "FAILED" and i <= self.build_phase:
+                if i < self.build_phase:
+                    marker = "✓"
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+                else:
+                    marker = "✗"
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_ERROR))
+            elif i < self.build_phase:
+                marker = "✓"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+            elif i == self.build_phase and self.deploy_status == "BUILDING":
+                marker = self.SPINNER[self.spinner_frame % len(self.SPINNER)]
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+            else:
+                marker = "○"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_PENDING))
+
+            self.stdscr.addstr(y, 4, f"{marker} {phase_name}: {phase_desc}"[:w-6])
+
+            # Reset colors
+            if self.has_colors:
+                self.stdscr.attroff(curses.color_pair(self.COLOR_COMPLETED))
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+                self.stdscr.attroff(curses.color_pair(self.COLOR_PENDING))
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ERROR))
+            y += 1
+
+        y += 1
+
+        # Service deployment section
+        self.stdscr.attron(curses.A_BOLD)
+        self.stdscr.addstr(y, 2, "SERVICE DEPLOYMENT")
+        self.stdscr.attroff(curses.A_BOLD)
+        y += 1
+
+        for i, (state_name, state_desc) in enumerate(self.SERVICE_STATES):
+            if self.deploy_status == "SUCCESS":
+                marker = "✓"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+            elif self.deploy_status == "FAILED" and self.deploy_status != "BUILDING":
+                if i <= self.service_state:
+                    if i < self.service_state:
+                        marker = "✓"
+                        if self.has_colors:
+                            self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+                    else:
+                        marker = "✗"
+                        if self.has_colors:
+                            self.stdscr.attron(curses.color_pair(self.COLOR_ERROR))
+                else:
+                    marker = "○"
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_PENDING))
+            elif self.deploy_status == "DEPLOYING":
+                if i < self.service_state:
+                    marker = "✓"
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_COMPLETED))
+                elif i == self.service_state:
+                    marker = self.SPINNER[self.spinner_frame % len(self.SPINNER)]
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+                else:
+                    marker = "○"
+                    if self.has_colors:
+                        self.stdscr.attron(curses.color_pair(self.COLOR_PENDING))
+            else:
+                # Still building
+                marker = "○"
+                if self.has_colors:
+                    self.stdscr.attron(curses.color_pair(self.COLOR_PENDING))
+
+            self.stdscr.addstr(y, 4, f"{marker} {state_name}: {state_desc}"[:w-6])
+
+            # Reset colors
+            if self.has_colors:
+                self.stdscr.attroff(curses.color_pair(self.COLOR_COMPLETED))
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ACTIVE) | curses.A_BOLD)
+                self.stdscr.attroff(curses.color_pair(self.COLOR_PENDING))
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ERROR))
+            y += 1
+
+        y += 1
+
+        # URL display
+        if self.app_url:
+            self.stdscr.attron(curses.A_BOLD)
+            self.stdscr.addstr(y, 2, "APPLICATION URL")
+            self.stdscr.attroff(curses.A_BOLD)
+            y += 1
+            if self.has_colors:
+                self.stdscr.attron(curses.color_pair(self.COLOR_TITLE))
+            self.stdscr.addstr(y, 4, self.app_url[:w-6])
+            if self.has_colors:
+                self.stdscr.attroff(curses.color_pair(self.COLOR_TITLE))
+            y += 2
+
+        # Error message
+        if self.error_message:
+            if self.has_colors:
+                self.stdscr.attron(curses.color_pair(self.COLOR_ERROR))
+            self.stdscr.addstr(y, 2, f"Error: {self.error_message}"[:w-4])
+            if self.has_colors:
+                self.stdscr.attroff(curses.color_pair(self.COLOR_ERROR))
+
+    def draw_deployment_footer(self):
+        """Draw footer for deployment screen."""
+        h, w = self.stdscr.getmaxyx()
+
+        # Horizontal line
+        self.stdscr.addstr(h - 3, 0, "─" * (w - 1))
+
+        if self.deploy_status in ("SUCCESS", "FAILED"):
+            controls = "[Enter] Exit  [c] Copy URL"
+        else:
+            controls = "[Ctrl+C] Run in background"
+
+        self.stdscr.addstr(h - 2, (w - len(controls)) // 2, controls)
+
+    def poll_build_status(self, image_name: str, namespace: str) -> str:
+        """Poll the build status from API.
+
+        Returns: BUILD_RUNNING, BUILD_SUCCESS, BUILD_FAILED
+        """
+        if not self.sdk_client:
+            return "BUILD_SUCCESS"  # Demo mode
+
+        try:
+            images = self.sdk_client.apps.get_images(namespace=namespace)
+            for img in images:
+                if image_name in img.get('metadata', {}).get('name', ''):
+                    status = img.get('status', {})
+                    conditions = status.get('conditions', [])
+
+                    for cond in conditions:
+                        if cond.get('type') == 'Ready':
+                            if cond.get('status') == 'True':
+                                return "BUILD_SUCCESS"
+                            reason = cond.get('reason', '')
+                            if 'Failed' in reason or 'Error' in reason:
+                                self.error_message = cond.get('message', 'Build failed')
+                                return "BUILD_FAILED"
+
+                    # Still building
+                    return "BUILD_RUNNING"
+            return "BUILD_RUNNING"
+        except Exception as e:
+            self.error_message = str(e)
+            return "BUILD_FAILED"
+
+    def poll_service_status(self, service_name: str, namespace: str) -> str:
+        """Poll the service status.
+
+        Returns: SERVICE_PENDING, SERVICE_READY, SERVICE_FAILED
+        """
+        # For now, check if build is done and service should be ready
+        # In a real implementation, would check Knative service status
+        if not self.sdk_client:
+            return "SERVICE_READY"  # Demo mode
+
+        try:
+            images = self.sdk_client.apps.get_images(namespace=namespace)
+            for img in images:
+                if service_name in img.get('metadata', {}).get('name', '').replace('-image', ''):
+                    status = img.get('status', {})
+                    conditions = status.get('conditions', [])
+
+                    for cond in conditions:
+                        if cond.get('type') == 'Ready' and cond.get('status') == 'True':
+                            return "SERVICE_READY"
+            return "SERVICE_PENDING"
+        except Exception:
+            return "SERVICE_PENDING"
+
+    def run_deployment_monitor(self, stdscr) -> bool:
+        """Run the deployment monitoring screen.
+
+        Returns True if deployment succeeded, False otherwise.
+        """
+        self.stdscr = stdscr
+        curses.curs_set(0)
+        stdscr.clear()
+        stdscr.timeout(100)  # 100ms for animation
+
+        self.init_colors()
+        self.deploy_start_time = time.time()
+        self.deploy_status = "BUILDING"
+        self.build_phase = 0
+        self.service_state = 0
+
+        app_name = self.data.get('app_name', 'app')
+        namespace = self.data.get('namespace', 'default')
+        image_name = f"{app_name}-image"
+
+        last_poll = 0
+        poll_interval = 3.0  # Poll every 3 seconds
+
+        while True:
+            stdscr.clear()
+            self.draw_deployment_header()
+            self.draw_deployment_progress()
+            self.draw_deployment_footer()
+            stdscr.refresh()
+
+            key = stdscr.getch()
+
+            # Handle exit on success/failure
+            if self.deploy_status in ("SUCCESS", "FAILED"):
+                if key == ord('\n') or key == ord('q'):
+                    break
+                elif key == ord('c') and self.app_url:
+                    # Copy URL (would need platform-specific clipboard handling)
+                    pass
+
+            # Handle Ctrl+C for background
+            if key == 3:  # Ctrl+C
+                return True  # Run in background
+
+            # Poll for status updates
+            current_time = time.time()
+            if current_time - last_poll >= poll_interval:
+                last_poll = current_time
+
+                if self.deploy_status == "BUILDING":
+                    build_result = self.poll_build_status(image_name, namespace)
+                    if build_result == "BUILD_SUCCESS":
+                        self.build_phase = len(self.BUILD_PHASES)
+                        self.deploy_status = "DEPLOYING"
+                    elif build_result == "BUILD_FAILED":
+                        self.deploy_status = "FAILED"
+                    else:
+                        # Simulate build phase progress
+                        elapsed = current_time - self.deploy_start_time
+                        self.build_phase = min(int(elapsed / 15), len(self.BUILD_PHASES) - 1)
+
+                elif self.deploy_status == "DEPLOYING":
+                    svc_result = self.poll_service_status(app_name, namespace)
+                    if svc_result == "SERVICE_READY":
+                        self.service_state = len(self.SERVICE_STATES)
+                        self.deploy_status = "SUCCESS"
+                        self.app_url = f"https://{app_name}.{namespace}.apps.clue2.app"
+                    elif svc_result == "SERVICE_FAILED":
+                        self.deploy_status = "FAILED"
+                    else:
+                        # Simulate service state progress
+                        elapsed = current_time - self.deploy_start_time
+                        build_time = len(self.BUILD_PHASES) * 15
+                        deploy_elapsed = elapsed - build_time
+                        self.service_state = min(int(deploy_elapsed / 5), len(self.SERVICE_STATES) - 1)
+
+            # Timeout check (10 minutes)
+            if time.time() - self.deploy_start_time > 600:
+                self.deploy_status = "FAILED"
+                self.error_message = "Deployment timed out"
+
+        return self.deploy_status == "SUCCESS"
+
+    def run_curses(self, stdscr):
+        """Main curses loop with animation."""
+        self.stdscr = stdscr
+        curses.curs_set(0)  # Hide cursor
+        stdscr.clear()
+        stdscr.timeout(100)  # 100ms timeout for animation
+
+        # Initialize colors
+        self.init_colors()
+
+        running = True
+        while running:
+            stdscr.clear()
+            self.draw_header()
+            self.draw_step()
+            self.draw_footer()
+            stdscr.refresh()
+
+            key = stdscr.getch()
+            if key != -1:  # -1 means timeout (no key pressed)
+                running = self.handle_input(key)
+
+        return self.data if self.data.get('confirmed') else None
+
+    def run(self) -> Optional[Dict[str, Any]]:
+        """Run the wizard."""
+        return curses.wrapper(self.run_curses)
+
+
+def run_curses_wizard(projects: List[Dict] = None, deploy_func: Callable = None, sdk_client=None) -> Optional[Dict[str, Any]]:
+    """
+    Run the curses-based deploy wizard.
+
+    Args:
+        projects: List of available projects (unused, for API compatibility)
+        deploy_func: Function to call for deployment
+        sdk_client: SDK client for monitoring deployment progress
+
+    Returns:
+        Wizard data if completed, None if cancelled
+    """
+    wizard = CursesWizard(projects=projects, deploy_func=deploy_func, sdk_client=sdk_client)
+    result = wizard.run()
+
+    if result and result.get('confirmed'):
+        # Call deploy function if provided
+        if deploy_func:
+            try:
+                deploy_func(result)
+            except Exception as e:
+                print(f"Deployment initiation error: {e}")
+                return result
+
+        # Run deployment monitor
+        success = curses.wrapper(wizard.run_deployment_monitor)
+
+        if success:
+            result['app_url'] = wizard.app_url
+            result['deploy_status'] = 'SUCCESS'
+        else:
+            result['deploy_status'] = 'FAILED'
+            result['error'] = wizard.error_message
+
+    return result
+
+
+def run_curses_wizard_demo() -> Optional[Dict[str, Any]]:
+    """Run the wizard in demo mode (no actual deployment)."""
+    wizard = CursesWizard(deploy_func=None, sdk_client=None)
+    result = wizard.run()
+
+    if result and result.get('confirmed'):
+        # Run deployment monitor in demo mode (simulated)
+        curses.wrapper(wizard.run_deployment_monitor)
+        result['app_url'] = wizard.app_url
+        result['deploy_status'] = wizard.deploy_status
+
+    return result
+
+
+if __name__ == "__main__":
+    import sys
+
+    if '--demo' in sys.argv:
+        result = run_curses_wizard_demo()
+    else:
+        result = run_curses_wizard()
+
+    if result:
+        print(f"\nWizard completed!")
+        if result.get('app_url'):
+            print(f"Application URL: {result['app_url']}")
+        print(f"Status: {result.get('deploy_status', 'N/A')}")
+    else:
+        print("Wizard cancelled")