CLI Commands API Reference¶

@app.callback(invoke_without_command=True, help="Initialize your app")
def init_cmd(
    force: bool = typer.Option(False, "--force", help="Force initialize"),
    template: str = typer.Option(
        "fastapi_hello",
        "--template",
        help="Template to use (eg: fastapi_hello or flask_hello)",
    ),
) -> None:
    """
    Initialize a new SFAI application in the current directory.

    Args:
        force: bool
            Whether to force initialization if app is already initialized
        template: str
            Template to use for scaffolding the app (eg: fastapi_hello or flask_hello)

    Returns:
        None
    """
    # Call the Python API function
    result = init(template=template, force=force)

    if not result.success:
        console.print(
            f"{WARNING_EMOJI} [{WARNING_COLOR}] App {result.app_name} "
            f"already initialized use --force to reinitialize[/]"
        )
        return

    app_name = result.app_name

    console.print(f"{SUCCESS_EMOJI} App initialized!")
    console.print(f"{APP_NAME_EMOJI} App name: {app_name}")
    console.print(f"{TEMPLATE_EMOJI} Template: {template}")

    console.print(
        f"\n{ROCKET_EMOJI} Next: Run `[cyan]sfai app deploy[/]` to build "
        f"and deploy your app.\n"
        f" Run `[cyan]sfai platform init[/]` to initialize a cloud "
        f"environment(heroku, aws).\n"
        f"{LIGHT_BULB_EMOJI} Tip: Run `[cyan]sfai app open[/]` to access "
        f"your app locally."
    )

@app.callback(
    invoke_without_command=True,
    help="Deploy an application to the configured environment.",
)
def deploy_cmd(
    # common options
    platform: Optional[str] = typer.Option(None, help="Platform to deploy to"),
    environment: Optional[str] = typer.Option(None, help="Environment to deploy to"),
    path: str = typer.Option(
        ".", help="Path to the app folder (default: current directory)"
    ),
    # k8s options
    values_path: Optional[str] = typer.Option(None, help="Path to Helm values file"),
    set_values: Optional[str] = typer.Option(
        None, help="Additional values to set for Helm"
    ),
    # heroku options
    commit_message: Optional[str] = typer.Option(None, help="Commit message"),
    branch: Optional[str] = typer.Option(None, help="Branch name"),
) -> None:
    """
    Deploy the current application to the specified environment.

    Args:
        platform: Optional[str]
            Platform to deploy to
        environment: str
            Environment to deploy to (defaults to "default")
        path: str
            Path to the app folder
        values_path: Optional[str]
            Path to Helm values file
        set_values: Optional[str]
            Additional values to set for Helm
        commit_message: Optional[str]
            Commit message
        branch: Optional[str]
            Branch name
    Returns:
        None
    """

    console.print(f"{ROCKET_EMOJI} Deploying application...")

    result = deploy(
        platform=platform,
        environment=environment,
        path=path,
        values_path=values_path,
        set_values=set_values,
        commit_message=commit_message,
        branch=branch,
    )

    if result.success:
        console.print(f"{CELEBRATE_EMOJI} {result.message}")
    else:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")

@app.callback(invoke_without_command=True, help="Show status of the current app")
def status_cmd(
    platform: Optional[str] = typer.Option(None, help="Platform to show status from"),
    environment: Optional[str] = typer.Option(
        None, help="Environment to show status from"
    ),
) -> None:
    """
    Show the status of the current app from context.

    Args:
        platform: Optional[str]
            Platform to show status from
        environment: str
            Environment to show status from (defaults to "default")
    """

    result = status(platform=platform, environment=environment)
    if not result.success:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")
        return

@app.callback(invoke_without_command=True, help="Show logs for the current app")
def logs_cmd(
    platform: Optional[str] = typer.Option(None, help="Platform to show logs from"),
    environment: Optional[str] = typer.Option(
        None, help="Environment to show logs from"
    ),
) -> None:
    """
    Show logs for the current app.

    Args:
        platform: Optional[str]
            Platform to show logs from
        environment: str
            Environment to show logs from (defaults to "default")
    """

    result = logs(platform=platform, environment=environment)
    if not result.success:
        console.print(
            f"{ERROR_EMOJI} [{ERROR_COLOR}] unable to fetch logs: {result.error}[/]"
        )
        return

@app.callback(invoke_without_command=True, help="Delete the current app")
def delete_cmd(
    platform: Optional[str] = typer.Option(None, help="Platform to delete from"),
    environment: Optional[str] = typer.Option(None, help="Environment to delete from"),
):
    """
    Delete the current app deployment

    Args:
        platform: Optional[str]
            Platform to delete from
        environment: str
            Environment to delete from (defaults to "default")
    """

    result = delete(platform=platform, environment=environment)

    if not result.success:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")
        raise typer.Exit(code=1)

    name = result.app_name

    console.print(f"{SUCCESS_EMOJI} Deleted app '{name}'...")

@app.callback(invoke_without_command=True, help="Open the current app in your browser")
def open_cmd(
    platform: Optional[str] = typer.Option(None, help="Platform to open"),
    environment: Optional[str] = typer.Option(None, help="Environment to open"),
    path: str = typer.Option("/docs", help="API path to open"),
    port: int = typer.Option(8080, help="Local port"),
    tunnel: bool = typer.Option(False, help="Use Cloudflare tunnel"),
    url: str = typer.Option(None, help="URL to open"),
):
    """
    Open the current app in your browser.

    Args:
        platform: Optional[str]
            Platform to open
        environment: str
            Environment to open (defaults to "default")
        path: str
            The path to open
            default: /docs
        port: int
            The port to open
            default: 8080
        tunnel: bool
            Whether to use a tunnel
            default: False
        url: str
            The URL to open
    Returns:
        dict[str, Any]
    """

    result = open(
        platform=platform,
        environment=environment,
        path=path,
        port=port,
        tunnel=tunnel,
        url=url,
    )

    if not result.success:
        console.print(f"{ERROR_EMOJI} [red]{result.error}[/]")
        raise typer.Exit(1)

    if result.url:
        console.print(
            f"{PORT_EMOJI} Opening {result.platform} app: [bold blue]{result.url}[/]"
        )
        webbrowser.open(result.url)
        return

    # Port-forward confirmed
    app_name = result.app_name
    console.print(
        f"{PORT_EMOJI} Port-forwarding svc/{app_name}-service → http://localhost:{port}"
    )
    time.sleep(3)
    if result.pf_proc.poll() is not None:
        console.print(f"{ERROR_EMOJI} Port-forwarding failed. Check service status.")
        return
    console.print(f"{SUCCESS_EMOJI} Port forwarding established.")

    tunnel_proc = None
    if tunnel:
        try:
            url, tunnel_proc = start_cloudflare_tunnel(port, path)
            console.print(f"{LINK_EMOJI} Tunnel ready: [bold blue]{url}[/]")
            webbrowser.open(url)
            console.print(f"{TUNNEL_EMOJI} Press Ctrl+C to stop...")
            tunnel_proc.wait()
        finally:
            if tunnel_proc and tunnel_proc.poll() is None:
                tunnel_proc.terminate()
    elif result["platform"] != "local" and result["tunnel"]:
        console.print(f"{ERROR_EMOJI} Tunnel is only supported for local apps")
    else:
        url = f"http://localhost:{port}{path}"
        console.print(f"{WEB_EMOJI} Opening [bold blue]{url}[/]")
        webbrowser.open(url)
        result["pf_proc"].wait()

    if result["pf_proc"].poll() is None:
        result["pf_proc"].terminate()

def start_cloudflare_tunnel(port: int, path: str) -> tuple[str, subprocess.Popen]:
    """
    Start a Cloudflare tunnel for a service.

    Args:
        port: int
            The port to forward
        path: str
            The path to open
    Returns:
        tuple[str, subprocess.Popen]
    """
    proc = subprocess.Popen(
        ["cloudflared", "tunnel", "--url", f"http://localhost:{port}"],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        bufsize=1,
    )
    url_holder = {"url": None}

    def parse():
        for line in iter(proc.stdout.readline, ""):
            match = re.search(r"https://[^\s]+\.trycloudflare\.com", line)
            if match:
                candidate = match.group(0).rstrip("/") + path
                try:
                    if requests.get(candidate, timeout=5).status_code == 200:
                        url_holder["url"] = candidate
                        break
                except requests.RequestException:
                    continue

    threading.Thread(target=parse, daemon=True).start()

    with Status(f"{UPDATE_EMOJI} Finding tunnel URL...", console=console):
        for _ in range(MAX_RETRIES):
            if url_holder["url"] or proc.poll() is not None:
                break
            time.sleep(RETRY_DELAY)

    if not url_holder["url"]:
        proc.terminate()
        raise RuntimeError(f"{ERROR_EMOJI} Tunnel URL failed after retries.")

    return url_holder["url"], proc

@app.callback(invoke_without_command=True)
def init_cmd(
    service: str = typer.Option(None, help="service name, e.g. mulesoft, heroku, aws"),
    profile_name: str = typer.Option(
        None, help="profile name to store credentials under"
    ),
    interactive: bool = typer.Option(
        False, "-i", "--interactive", help="Run in interactive mode"
    ),
    # credentials flags
    org_id: str = typer.Option(None, help="MuleSoft organization ID"),
    environment_id: str = typer.Option(None, help="MuleSoft environment ID"),
    client_id: str = typer.Option(None, help="MuleSoft client ID"),
    client_secret: str = typer.Option(None, help="MuleSoft client secret"),
) -> None:
    """
    Configure service connection settings.

    Args:
        service: str
            Name of the service to configure credentials for
        profile_name: str
            Name of the profile to store credentials under
        interactive: bool
            Run in interactive mode
        org_id: str
            MuleSoft organization ID
        environment_id: str
            MuleSoft environment ID
        client_id: str
            MuleSoft client ID
        client_secret: str
            MuleSoft client secret
    Returns:
        None
    """
    # Prompt for service if missing
    if not service:
        service = Prompt.ask(
            "Which service to configure (e.g., mulesoft)", default="mulesoft"
        )

    # Get schema fields and validate service
    schema_fields = _get_schema_fields(service)
    if not schema_fields:
        console.print(
            f"{ERROR_EMOJI} [{ERROR_COLOR}]Invalid or missing service: {service}[/]"
        )
        return

    # Define profile name
    profile_name = profile_name or "default"
    if interactive:
        profile_name = Prompt.ask(
            f"Enter {service} profile name for storing credentials", default="default"
        )

    # all CLI values captured
    all_cli_args = {
        "org_id": org_id,
        "environment_id": environment_id,
        "client_id": client_id,
        "client_secret": client_secret,
    }

    credentials = {}

    # Collect credentials
    if interactive:
        for field_name, description in schema_fields.items():
            val = Prompt.ask(
                f"{SECURITY_EMOJI} {description}",
                password=("secret" in field_name.lower()),
            )
            if not val:
                console.print(
                    f"{ERROR_EMOJI} [{ERROR_COLOR}]Missing required field: "
                    f"{description}[/]"
                )
                return
            credentials[field_name] = val
    else:
        for field_name in schema_fields:
            val = all_cli_args.get(field_name)
            if val is not None:
                credentials[field_name] = val

        if not credentials:
            for field_name, description in schema_fields.items():
                val = Prompt.ask(
                    f"{SECURITY_EMOJI} {description}",
                    password=("secret" in field_name.lower()),
                )
                if not val:
                    console.print(
                        f"{ERROR_EMOJI} [{ERROR_COLOR}]Missing required field: "
                        f"{description}[/]"
                    )
                    return
                credentials[field_name] = val

        # warn if irrelevant keys were passed
        invalid_keys = [
            k
            for k in all_cli_args
            if k not in schema_fields and all_cli_args[k] is not None
        ]
        if invalid_keys:
            console.print(
                f"{WARNING_EMOJI} Ignored keys not part of {service}: "
                f"{', '.join(invalid_keys)}"
            )

    # Use the API function
    result = init(service=service, config=credentials, profile_name=profile_name)

    if result.success:
        console.print(
            f"{SUCCESS_EMOJI} [{SUCCESS_COLOR}]{service.capitalize()}[/] "
            f"credentials saved under profile [bold]{profile_name}[/]."
        )
    else:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")

@app.callback(invoke_without_command=True)
def update_cmd(
    service: str = typer.Option(..., help="Service name"),
    profile_name: Optional[str] = typer.Option("default", help="Profile to update"),
    interactive: bool = typer.Option(False, "--interactive", "-i"),
    # full list of possible fields
    org_id: Optional[str] = None,
    environment_id: Optional[str] = None,
    client_id: Optional[str] = None,
    client_secret: Optional[str] = None,
):
    """Update specific values in an existing service profile

    Args:
        service: str
            Service name
        profile_name: Optional[str]
            Profile to update
        interactive: bool
            Run in interactive mode
        org_id: Optional[str]
            MuleSoft organization ID
        environment_id: Optional[str]
            MuleSoft environment ID
        client_id: Optional[str]
            MuleSoft client ID
        client_secret: Optional[str]
            MuleSoft client secret
    """
    schema = _get_service_schema(service)
    if not schema:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]Invalid service: {service}[/]")
        return

    # Check if profile exists BEFORE prompting for updates
    exists, error = profile_exists(service, profile_name)
    if not exists:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{error}[/]")
        return

    schema_keys = set(schema.keys())

    all_cli_args = {
        "org_id": org_id,
        "environment_id": environment_id,
        "client_id": client_id,
        "client_secret": client_secret,
    }

    updates = {}

    if interactive or not any(all_cli_args.get(key) for key in schema_keys):
        # prompt user for each field
        for key, label in schema.items():
            val = Prompt.ask(
                f"{UPDATE_EMOJI} New value for {label} (leave blank to skip)"
            )
            if val:
                updates[key] = val
    else:
        # use only explicitly provided cli args
        for key in schema_keys:
            val = all_cli_args.get(key)
            if val:
                updates[key] = val

    # Don't update if no changes
    if not updates:
        console.print(f"{SUCCESS_EMOJI} No updates provided. Profile unchanged.")
        return

    # Call the API
    result = update(service, updates, profile_name)

    if result.success:
        console.print(
            f"{SUCCESS_EMOJI} Updated [{SUCCESS_COLOR}]{service}[/] profile "
            f"[bold]{profile_name}[/] with new values."
        )
    else:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")

@app.callback(invoke_without_command=True)
def list_cmd(
    service: Optional[str] = typer.Option(None, help="Filter by specific service name"),
):
    """List service profiles

    Args:
        service: Optional[str]
            Filter by specific service name
    """
    result = list(service)

    if not result.success:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")
        return

    profiles = result.profiles

    if not profiles:
        console.print(f"[{WARNING_COLOR}]No service profiles found.[/]")
        return

    if service:
        # Single service display
        console.print(f"[{SUCCESS_COLOR}]{service.capitalize()} Profiles[/]:")
        for name in profiles:
            console.print(f"- {name}")
    else:
        # All services display
        for svc, svc_profiles in profiles.items():
            console.print(f"\n[{SUCCESS_COLOR}]{svc.capitalize()} Profiles[/]:")
            for name in svc_profiles:
                console.print(f"- {name}")

@app.callback(invoke_without_command=True)
def view_cmd(
    service: str = typer.Option(..., help="Service name"),
    profile_name: Optional[str] = typer.Option("default", help="Profile to view"),
):
    """View details of a service profile

    Args:
        service: str
            Service name
        profile_name: Optional[str]
            Profile to view
    """

    # Get schema to validate service
    schema = _get_service_schema(service)
    if not schema:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]Invalid service: {service}[/]")
        return

    # View the profile
    result = view(service, profile_name)

    if not result.success:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")
        return

    # Display profile information in a table
    table = Table(title=f"{service.capitalize()} Profile: {profile_name}")
    table.add_column("Key", style="cyan")
    table.add_column("Value", style="green")

    profile = result.data
    for key, value in profile.items():
        table.add_row(key, str(value))

    console.print(table)

@app.callback(invoke_without_command=True)
def delete_cmd(
    service: str = typer.Option(..., help="Service name"),
    profile_name: Optional[str] = typer.Option("default", help="Profile to delete"),
    force: bool = typer.Option(
        False, "--force", "-f", help="Delete without confirmation"
    ),
):
    """Delete a service profile

    Args:
        service: str
            Service name
        profile_name: Optional[str]
            Profile to delete
        force: bool
            Delete without confirmation

    Returns:
        None
    """

    # Get schema to validate service
    schema = _get_service_schema(service)
    if not schema:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]Invalid service: {service}[/]")
        return

    # Ask for confirmation unless force is specified
    if not force:
        confirmed = Confirm.ask(
            f"{QUESTION_EMOJI} Are you sure you want to delete the profile "
            f"'{profile_name}' for service '{service}'?",
            default=False,
        )
        if not confirmed:
            console.print("Operation cancelled.")
            return

    # Delete the profile
    result = delete(service, profile_name)

    if result.success:
        console.print(f"{SUCCESS_EMOJI} [{SUCCESS_COLOR}]{result.message}[/]")
    else:
        console.print(f"{ERROR_EMOJI} [{ERROR_COLOR}]{result.error}[/]")

@app.callback(
    invoke_without_command=True,
    help="Initialize or update cloud/local environment in context",
)
def init_platform_cmd(
    platform: Optional[str] = typer.Option(
        None, help="Platform type (local, eks, gcp, heroku)"
    ),
    environment: str = typer.Option("default", help="Environment name"),
    # heroku options
    app_name: Optional[str] = typer.Option(None, help="Heroku app name (for heroku)"),
    team_name: Optional[str] = typer.Option(None, help="Heroku team name (for heroku)"),
    private_space: Optional[str] = typer.Option(
        None, help="Heroku private space name (for heroku)"
    ),
    deployment_type: Optional[str] = typer.Option(
        None, help="Deployment type (for heroku)"
    ),
    routing: Optional[str] = typer.Option(None, help="Routing type (for heroku)"),
    # eks options
    cluster_name: Optional[str] = typer.Option(None, help="EKS cluster name (for eks)"),
    region: Optional[str] = typer.Option(None, help="AWS region (for eks)"),
    profile: Optional[str] = typer.Option(None, help="AWS profile (for eks)"),
    namespace: Optional[str] = typer.Option(None, help="namespace (for eks)"),
    ecr_repo: Optional[str] = typer.Option(None, help="ECR repository (for eks)"),
    # interactive options
    interactive: bool = typer.Option(
        False, "-i", "--interactive", help="Interactive mode"
    ),
    skip_confirm: bool = typer.Option(
        False, "-y", "--yes", help="Skip confirmation of default values"
    ),
) -> None:
    """
    Initialize or update cloud/local environment in context

    Args:
        platform: str
            Platform type (local, eks, gcp, heroku)
        environment: str
            Environment name (defaults to "default")
        app_name: Optional[str]
            Heroku app name (for heroku)
        team_name: Optional[str]
            Heroku team name (for heroku)
        private_space: Optional[str]
            Heroku private space name (for heroku)
        deployment_type: Optional[str]
            Deployment type (for heroku)
        routing: Optional[str]
            Routing type (for heroku)
        cluster_name: Optional[str]
            EKS cluster name (for eks)
        region: Optional[str]
            AWS region (for eks)
        profile: Optional[str]
            AWS profile (for eks)
        namespace: Optional[str]
            namespace (for eks)
        ecr_repo: Optional[str]
            ECR repository (for eks)
        interactive: bool
            Interactive mode
        skip_confirm: bool
            Skip confirmation of default values
    """
    context = ctx_mgr.read_context()
    if not context:
        console.print(f"{ERROR_EMOJI} No app context found. Run `sfai init app` first.")
        return

    current_env = context.get("active_env", {})

    if not platform:
        platform = Prompt.ask(
            "Enter the platform type",
            choices=["eks", "heroku", "minikube"],
            default=current_env or "heroku",
        )
    environment = Prompt.ask(
        "Enter the environment",
        default=environment or context.get("environment", "default"),
    )

    if platform == "heroku":
        if interactive:
            team_name = Prompt.ask(
                "Enter the team name", default=team_name or context.get("team_name", "")
            )
            if team_name:
                private_space = Prompt.ask(
                    "Enter the private space name",
                    default=private_space or context.get("private_space", ""),
                )
            else:
                private_space = ""
            deployment_type = Prompt.ask(
                "Enter the deployment type",
                choices=["container", "buildpack"],
                default=deployment_type or context.get("deployment_type", "buildpack"),
            )
            routing = Prompt.ask(
                "Enter the routing type",
                choices=["internal", "public"],
                default=routing or context.get("routing", "public"),
            )
        else:
            app_name = app_name or context.get("app_name", "").lower()
            team_name = team_name or context.get("team_name", "")
            private_space = private_space or context.get("private_space", "")
            deployment_type = deployment_type or context.get(
                "deployment_type", "buildpack"
            )
            routing = routing or context.get("routing", "public")
            if not skip_confirm:
                console.print(
                    f"Initializing [cyan]{platform}[/] environment with the "
                    f"following values:"
                )
                console.print(f"  App Name: [cyan]{app_name}[/]")
                console.print(f"  Team Name: [cyan]{team_name or ''}[/]")
                console.print(f"  Private Space: [cyan]{private_space or ''}[/]")
                console.print(f"  Deployment Type: [cyan]{deployment_type}[/]")
                console.print(f"  Routing Type: [cyan]{routing}[/]")
                confirm = Prompt.ask(
                    "Are you sure you want to continue?",
                    choices=["y", "n"],
                    default="y",
                )
                if confirm.lower() not in ["y", "yes"]:
                    console.print(
                        f"{ERROR_EMOJI} Environment initialization cancelled."
                    )
                    return

    if platform == "eks":
        if interactive:
            cluster_name = Prompt.ask(
                "Enter the EKS cluster name",
                default=cluster_name or context.get("cluster_name"),
            )
            region = Prompt.ask(
                "Enter the region", default=region or context.get("region", "us-west-2")
            )
            profile = Prompt.ask(
                "Enter the profile",
                default=profile or context.get("profile", "default"),
            )
            namespace = Prompt.ask(
                "Enter the namespace",
                default=namespace or context.get("namespace", "default"),
            )
            ecr_repo = Prompt.ask(
                "Enter the ECR repository",
                default=ecr_repo or context.get("ecr_repo", f"{app_name}"),
            )
        else:
            cluster_name = cluster_name or context.get("cluster_name")
            region = region or context.get("region", "us-east-1")
            profile = profile or context.get("profile", "default")
            namespace = namespace or context.get("namespace", "default")
            ecr_repo = ecr_repo or context.get("ecr_repo", f"{app_name}")
            if not skip_confirm:
                console.print(
                    f"Initializing [cyan]{platform}[/] environment with the "
                    f"following values:"
                )
                console.print(f"  Cluster Name: [cyan]{cluster_name}[/]")
                console.print(f"  Region: [cyan]{region}[/]")
                console.print(f"  Profile: [cyan]{profile}[/]")
                console.print(f"  Namespace: [cyan]{namespace}[/]")
                console.print(f"  ECR Repository: [cyan]{ecr_repo}[/]")
                confirm = Prompt.ask(
                    "Are you sure you want to continue?",
                    choices=["y", "n"],
                    default="y",
                )
                if confirm.lower() not in ["y", "yes"]:
                    console.print(
                        f"{ERROR_EMOJI} Environment initialization cancelled."
                    )
                    return

    result = init(
        platform=platform,
        environment=environment,
        # heroku options
        app_name=app_name,
        team_name=team_name,
        private_space=private_space,
        deployment_type=deployment_type,
        routing=routing,
        # eks options
        cluster_name=cluster_name,
        region=region,
        profile=profile,
        namespace=namespace,
        ecr_repo=ecr_repo,
        # interactive options
        interactive=interactive,
        skip_confirm=skip_confirm,
    )

    if result.success:
        # Get the environment-specific app name from result data if available
        environment_app_name = result.data.get("app_name") if result.data else None
        app_name = environment_app_name or context.get("app_name")
        console.print(
            f"{SUCCESS_EMOJI} {platform} environment initialized → app_name: {app_name}"
        )
        if team_name:
            console.print(f"🔗 Team: {team_name}")
        if private_space:
            console.print(f"🔗 Private Space: {private_space}")
        console.print(
            f"{ROCKET_EMOJI} Next: Run `sfai app deploy` to deploy your app to "
            f"{platform}."
        )
    else:
        console.print(f"{ERROR_EMOJI} {result.error}")