fastapi-cloud-cli 0.19.0__tar.gz → 0.20.0__tar.gz

{fastapi_cloud_cli-0.19.0 → fastapi_cloud_cli-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.19.0
+Version: 0.20.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT
@@ -33,7 +33,7 @@ Requires-Dist: typer>=0.16.0
 Requires-Dist: uvicorn[standard]>=0.17.6
 Requires-Dist: rignore>=0.5.1
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: rich-toolkit>=0.19.7
+Requires-Dist: rich-toolkit>=0.20.1
 Requires-Dist: pydantic[email]>=2.7.4; python_version < "3.13"
 Requires-Dist: pydantic[email]>=2.8.0; python_version == "3.13"
 Requires-Dist: pydantic[email]>=2.12.0; python_version >= "3.14"

{fastapi_cloud_cli-0.19.0 → fastapi_cloud_cli-0.20.0}/pyproject.toml

@@ -33,7 +33,7 @@ dependencies = [
     "uvicorn[standard] >= 0.17.6",
     "rignore >= 0.5.1",
     "httpx >= 0.27.0",
-    "rich-toolkit >= 0.19.7",
+    "rich-toolkit>=0.20.1",
     "pydantic[email] >= 2.7.4; python_version < '3.13'",
     "pydantic[email] >= 2.8.0; python_version == '3.13'",
     "pydantic[email] >= 2.12.0; python_version >= '3.14'",
@@ -41,7 +41,7 @@ dependencies = [
     "fastar >= 0.10.0",
     "detect-installer>=0.1.0",
 ]
-version = "0.19.0"
+version = "0.20.0"
 
 [project.license]
 text = "MIT"
@@ -61,12 +61,12 @@ Changelog = "https://github.com/fastapilabs/fastapi-cloud-cli/blob/main/release-
 [dependency-groups]
 dev = [
     "prek>=0.2.24,<1.0.0",
-    "pytest>=7.0.0,<9.0.0",
+    "pytest>=7.0.0,<10.0.0",
     "coverage[toml]>=7.2,<8.0",
-    "mypy==1.14.1",
-    "ruff==0.13.0",
-    "respx==0.22.0",
-    "time-machine==2.15.0",
+    "mypy==2.1.0",
+    "ruff==0.15.15",
+    "respx==0.23.1",
+    "time-machine==2.19.0",
     "ty>=0.0.25",
     "zizmor>=1.24.1",
 ]
@@ -167,3 +167,14 @@ known-third-party = [
 
 [tool.ruff.lint.pyupgrade]
 keep-runtime-typing = true
+
+[tool.typos.files]
+extend-exclude = [
+    "release-notes.md",
+    "uv.lock",
+    "coverage/",
+    "htmlcov/",
+]
+
+[tool.typos.default.extend-identifiers]
+alls = "alls"

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.20.0"

{fastapi_cloud_cli-0.19.0 → fastapi_cloud_cli-0.20.0}/src/fastapi_cloud_cli/cli.py

@@ -4,14 +4,18 @@ import typer
 from rich import print
 
 from . import __version__
+from .commands.apps import apps_app
+from .commands.apps.link import link_app
+from .commands.apps.unlink import unlink_app
+from .commands.auth import auth_app
 from .commands.deploy import deploy
+from .commands.deployments import deployments_app
 from .commands.env import env_app
-from .commands.link import link
 from .commands.login import login
 from .commands.logout import logout
 from .commands.logs import logs
 from .commands.setup_ci import setup_ci
-from .commands.unlink import unlink
+from .commands.teams import teams_app
 from .commands.whoami import whoami
 from .logging import setup_logging
 from .utils.sentry import init_sentry
@@ -29,7 +33,7 @@ def version_callback(value: bool) -> None:
 
 cloud_app = typer.Typer(
     rich_markup_mode="rich",
-    help="Manage [bold]FastAPI[/bold] Cloud deployments. 🚀",
+    help="Manage [bold]FastAPI[/bold] Cloud deployments.",
     no_args_is_help=True,
 )
 
@@ -54,15 +58,19 @@ def cloud_main(
 
 # fastapi cloud [command]
 cloud_app.command()(deploy)
-cloud_app.command()(link)
+cloud_app.command("link")(link_app)
 cloud_app.command()(login)
 cloud_app.command()(logs)
 cloud_app.command()(logout)
 cloud_app.command()(whoami)
-cloud_app.command()(unlink)
+cloud_app.command("unlink")(unlink_app)
 cloud_app.command()(setup_ci)
 
 cloud_app.add_typer(env_app, name="env")
+cloud_app.add_typer(auth_app, name="auth")
+cloud_app.add_typer(apps_app, name="apps")
+cloud_app.add_typer(deployments_app, name="deployments")
+cloud_app.add_typer(teams_app, name="teams")
 
 # fastapi [command]
 app.command()(deploy)

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/_flow.py

@@ -0,0 +1,159 @@
+import logging
+import time
+
+import httpx
+from pydantic import BaseModel
+from rich_toolkit import RichToolkit
+from rich_toolkit.progress import Progress
+
+from fastapi_cloud_cli.config import Settings
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.auth import AuthConfig, AuthMode, write_auth_config
+from fastapi_cloud_cli.utils.cli import FastAPIRichToolkit
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_LOGIN_TIMEOUT_SECONDS = 300
+
+
+class AuthorizationData(BaseModel):
+    user_code: str
+    device_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    interval: int = 5
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+
+
+class LoginOutput(BaseModel):
+    authenticated: bool
+    auth_mode: AuthMode
+
+
+class DeviceAuthorizationOutput(BaseModel):
+    verification_uri: str
+    verification_uri_complete: str
+    user_code: str
+    device_code: str
+    interval: int
+
+
+class LoginTimeoutError(Exception):
+    pass
+
+
+def render_login_output(data: LoginOutput, toolkit: RichToolkit) -> None:
+    toolkit.print("Now you are logged in! 🚀")
+
+
+def device_authorization_output(
+    authorization_data: AuthorizationData,
+) -> DeviceAuthorizationOutput:
+    return DeviceAuthorizationOutput(
+        verification_uri=authorization_data.verification_uri,
+        verification_uri_complete=authorization_data.verification_uri_complete,
+        user_code=authorization_data.user_code,
+        device_code=authorization_data.device_code,
+        interval=authorization_data.interval,
+    )
+
+
+def start_device_authorization(
+    client: httpx.Client,
+) -> AuthorizationData:
+    settings = Settings.get()
+
+    response = client.post(
+        "/login/device/authorization", data={"client_id": settings.client_id}
+    )
+    logger.debug(f"Device authorization response status code: {response.status_code}")
+
+    response.raise_for_status()
+
+    return AuthorizationData.model_validate_json(response.text)
+
+
+def fetch_access_token(
+    client: httpx.Client,
+    device_code: str,
+    interval: int,
+    timeout: int = DEFAULT_LOGIN_TIMEOUT_SECONDS,
+) -> str:
+    settings = Settings.get()
+    start = time.monotonic()
+
+    logger.debug("Starting to poll for access token")
+    while True:
+        response = client.post(
+            "/login/device/token",
+            data={
+                "device_code": device_code,
+                "client_id": settings.client_id,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            },
+        )
+        logger.debug(f"Token response status code: {response.status_code}")
+
+        if response.status_code not in (200, 400):
+            response.raise_for_status()
+
+        if response.status_code == 400:
+            data = response.json()
+            error = data.get("error")
+            logger.debug(f"Token response error: {error}")
+
+            if error != "authorization_pending":
+                response.raise_for_status()
+
+        if response.status_code == 200:
+            break
+
+        remaining = timeout - (time.monotonic() - start)
+        if remaining <= 0:
+            raise LoginTimeoutError
+
+        sleep_for = min(interval, remaining)
+
+        logger.debug(f"Sleeping for {sleep_for} seconds before retrying...")
+        time.sleep(sleep_for)
+
+    response_data = TokenResponse.model_validate_json(response.text)
+    logger.debug("Access token received successfully.")
+
+    return response_data.access_token
+
+
+def complete_device_login(
+    *,
+    client: APIClient,
+    progress: Progress,
+    toolkit: FastAPIRichToolkit,
+    device_code: str,
+    interval: int,
+    timeout: int,
+    cancel_hint: str,
+) -> LoginOutput:
+    try:
+        with client.handle_http_errors(progress, toolkit=toolkit):
+            access_token = fetch_access_token(client, device_code, interval, timeout)
+    except LoginTimeoutError:
+        message = "Login timed out before authorization completed."
+        toolkit.fail(
+            "timeout",
+            message,
+            hint="Try again with a longer --timeout value.",
+        )
+    except KeyboardInterrupt:
+        message = "Login cancelled before authorization completed."
+        toolkit.fail(
+            "cancelled",
+            message,
+            hint=cancel_hint,
+        )
+
+    write_auth_config(AuthConfig(access_token=access_token))
+
+    return LoginOutput(authenticated=True, auth_mode="user")

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/apps/__init__.py

@@ -0,0 +1,21 @@
+import typer
+
+from fastapi_cloud_cli.commands.apps.create import create_app
+from fastapi_cloud_cli.commands.apps.get import get_app
+from fastapi_cloud_cli.commands.apps.link import link_app
+from fastapi_cloud_cli.commands.apps.list import list_apps
+from fastapi_cloud_cli.commands.apps.unlink import unlink_app
+from fastapi_cloud_cli.commands.logs import logs
+
+apps_app = typer.Typer(
+    no_args_is_help=True,
+    help="Manage your FastAPI Cloud apps.",
+)
+apps_app.command("create")(create_app)
+apps_app.command("get")(get_app)
+apps_app.command("link")(link_app)
+apps_app.command("list")(list_apps)
+apps_app.command("logs")(logs)
+apps_app.command("unlink")(unlink_app)
+
+__all__ = ["apps_app"]

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/apps/create.py

@@ -0,0 +1,179 @@
+import logging
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from pydantic import BaseModel, Field
+from rich_toolkit import RichToolkit
+
+from fastapi_cloud_cli.commands.apps.list import _prompt_for_team
+from fastapi_cloud_cli.commands.deploy.archive import (
+    _get_app_name,
+    validate_app_directory,
+)
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.apps import AppConfig, write_app_config
+from fastapi_cloud_cli.utils.auth import Identity
+from fastapi_cloud_cli.utils.cli import get_rich_toolkit
+from fastapi_cloud_cli.utils.execution import JsonOutputOption
+
+logger = logging.getLogger(__name__)
+
+
+class CreatedApp(BaseModel):
+    id: str
+    team_id: str
+    slug: str
+    name: str
+    directory: str | None
+
+
+class AppsCreateOutput(BaseModel):
+    app: CreatedApp
+    linked: bool
+    path_to_link: Annotated[Path | None, Field(exclude=True)] = None
+
+
+def _create_app(
+    client: APIClient, *, team_id: str, name: str, directory: str | None
+) -> CreatedApp:
+    response = client.post(
+        "/apps/",
+        json={"team_id": team_id, "name": name, "directory": directory},
+    )
+    response.raise_for_status()
+
+    return CreatedApp.model_validate(response.json())
+
+
+def _render_apps_create_output(data: AppsCreateOutput, toolkit: RichToolkit) -> None:
+    toolkit.print(f"Created app [bold]{data.app.name}[/bold]", bullet=False)
+
+    if data.linked and data.path_to_link is not None:
+        toolkit.print(
+            f"Linked [bold]{data.path_to_link}[/bold] to [bold]{data.app.name}[/bold]",
+            bullet=False,
+        )
+
+
+def create_app(
+    team_id: Annotated[
+        str | None,
+        typer.Option(
+            "--team-id",
+            help="ID of the team where the app should be created.",
+        ),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option(
+            "--name",
+            help="Name of the app to create.",
+        ),
+    ] = None,
+    directory: Annotated[
+        str | None,
+        typer.Option(
+            "--directory",
+            help="Directory containing the app's pyproject.toml.",
+        ),
+    ] = None,
+    link: Annotated[
+        bool | None,
+        typer.Option(
+            "--link/--no-link",
+            help="Link the local directory to the created app.",
+        ),
+    ] = None,
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            help="Directory to link when --link is enabled.",
+        ),
+    ] = None,
+    json_output: JsonOutputOption = False,
+) -> Any:
+    """
+    Create a FastAPI Cloud app.
+    """
+    identity = Identity()
+    path_to_link = path or Path.cwd()
+
+    # JSON output is non-interactive, so it defaults to create-only unless --link is explicit.
+    link_app = link if link is not None else not json_output
+
+    with get_rich_toolkit(json_output=json_output) as toolkit:
+        if not identity.is_logged_in():
+            toolkit.fail(
+                "not_logged_in",
+                "No credentials found.",
+                hint="Run `fastapi cloud login` or set FASTAPI_CLOUD_TOKEN.",
+            )
+
+        if not link_app and path is not None:
+            toolkit.fail(
+                "invalid_input",
+                "Path can only be used when linking.",
+                hint="Pass --link or omit --path.",
+            )
+
+        with APIClient() as client:
+            if team_id is None:
+                if json_output:
+                    toolkit.fail(
+                        "missing_required_input",
+                        "Team ID is required.",
+                        hint="Pass --team-id to choose a team.",
+                    )
+
+                team = _prompt_for_team(toolkit, client)
+                team_id = team.id
+                toolkit.print_line()
+
+            if name is None:
+                if json_output:
+                    toolkit.fail(
+                        "missing_required_input",
+                        "App name is required.",
+                        hint="Pass --name to choose an app name.",
+                    )
+
+                name = toolkit.input(
+                    title="What's your app name?",
+                    default=_get_app_name(path_to_link),
+                    bullet=False,
+                )
+                toolkit.print_line()
+
+            directory = validate_app_directory(directory)
+
+            with toolkit.progress(
+                title="Creating app",
+                transient=True,
+            ) as progress:
+                with client.handle_http_errors(
+                    progress,
+                    default_message="Error creating app. Please try again later.",
+                    toolkit=toolkit,
+                ):
+                    app = _create_app(
+                        client,
+                        team_id=team_id,
+                        name=name,
+                        directory=directory,
+                    )
+
+        if link_app:
+            write_app_config(
+                path_to_link,
+                AppConfig(app_id=app.id, team_id=app.team_id),
+            )
+
+        result = AppsCreateOutput(
+            app=app,
+            linked=link_app,
+            path_to_link=path_to_link if link_app else None,
+        )
+
+        toolkit.success(result, render_output=_render_apps_create_output)

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/apps/get.py

@@ -0,0 +1,122 @@
+import logging
+from typing import Annotated, Any
+
+import typer
+from pydantic import BaseModel, Field
+from rich.text import Text
+from rich_toolkit import RichToolkit
+
+from fastapi_cloud_cli.commands.apps.list import (
+    App,
+    _get_app,
+    _get_app_dashboard_url,
+    _get_team,
+)
+from fastapi_cloud_cli.config import Settings
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.apps import resolve_app_id_or_fail
+from fastapi_cloud_cli.utils.auth import Identity
+from fastapi_cloud_cli.utils.cli import get_details_table, get_rich_toolkit
+from fastapi_cloud_cli.utils.execution import JsonOutputOption
+
+logger = logging.getLogger(__name__)
+
+
+class AppGetOutput(BaseModel):
+    app: App
+    dashboard_url: Annotated[str | None, Field(exclude=True)] = None
+
+
+def _render_app_get_output(data: AppGetOutput, toolkit: RichToolkit) -> None:
+    app = data.app
+
+    toolkit.print(f"[bold]{app.name}[/bold]", emoji="📦")
+    toolkit.print_line()
+    toolkit.print(
+        get_details_table(
+            [
+                ("id", app.id),
+                ("slug", app.slug),
+                (
+                    "directory",
+                    app.directory
+                    if app.directory is not None
+                    else Text("-", style="dim"),
+                ),
+                ("url", app.url if app.url is not None else Text("-", style="dim")),
+                (
+                    "dashboard",
+                    Text(data.dashboard_url, style=f"link {data.dashboard_url}")
+                    if data.dashboard_url is not None
+                    else Text("-", style="dim"),
+                ),
+                ("team id", app.team_id),
+            ]
+        )
+    )
+
+
+def get_app(
+    app_id: Annotated[
+        str | None,
+        typer.Argument(
+            help="ID of the app to return (defaults to the app linked to the current directory).",
+        ),
+    ] = None,
+    json_output: JsonOutputOption = False,
+) -> Any:
+    """
+    Get a FastAPI Cloud app by ID.
+    """
+    identity = Identity()
+
+    with get_rich_toolkit(json_output=json_output) as toolkit:
+        if not identity.is_logged_in():
+            toolkit.fail(
+                "not_logged_in",
+                "No credentials found.",
+                hint="Run `fastapi cloud login` or set FASTAPI_CLOUD_TOKEN.",
+            )
+
+        target_app_id = resolve_app_id_or_fail(
+            toolkit,
+            app_id=app_id,
+            hint="Pass an app ID or run `fastapi cloud apps create --link` first.",
+        )
+
+        with APIClient() as client:
+            with toolkit.progress(
+                title="Fetching app",
+                transient=True,
+            ) as progress:
+                with client.handle_http_errors(
+                    progress,
+                    default_message="Error fetching app. Please try again later.",
+                    not_found_message="App not found.",
+                    toolkit=toolkit,
+                ):
+                    app = _get_app(client, target_app_id)
+
+            dashboard_url = None
+            if not json_output:
+                with toolkit.progress(
+                    title="Fetching team",
+                    transient=True,
+                ) as progress:
+                    with client.handle_http_errors(
+                        progress,
+                        default_message="Error fetching team. Please try again later.",
+                        not_found_message="Team not found.",
+                        toolkit=toolkit,
+                    ):
+                        team = _get_team(client, app.team_id)
+
+                dashboard_url = _get_app_dashboard_url(
+                    app,
+                    team_slug=team.slug,
+                    settings=Settings.get(),
+                )
+
+            result = AppGetOutput(app=app, dashboard_url=dashboard_url)
+
+        toolkit.success(result, render_output=_render_app_get_output)