sweatstack-cli 0.11.0__tar.gz → 0.12.0__tar.gz

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.12.0] - 2026-10-13
+
+### Fixed
+
+- `login` no longer crashes after authenticating: it read a `name` claim that
+  the userinfo endpoint never returns. `login` and `status` now show
+  `given_name`/`family_name`, falling back to email.
+- `page init` now sends the slug to `PUT /api/v1/applications/{id}/page` as a
+  form field, as the API expects; it was sent as JSON and rejected with a 422.
+
+### Changed
+
+- `page deploy` now updates or creates: if the page doesn't exist, it is created
+  and the deploy goes ahead. With an application linked in `sweatstack.toml`, its
+  page is created at the slug. Without one, `deploy` asks to create a new
+  application with that page (the same flow as `page init`) and records it in
+  `sweatstack.toml`; non-interactively, it fails and points to `app link` and
+  `app create --page`.
+
 ## [0.11.0] - 2026-06-30
 
 ### Added

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sweatstack-cli
-Version: 0.11.0
+Version: 0.12.0
 Summary: Command-line interface for SweatStack — the sports data platform for developers
 Project-URL: Homepage, https://sweatstack.no
 Project-URL: Documentation, https://docs.sweatstack.no
@@ -134,6 +134,10 @@ sweatstack page deploy
 sweatstack page deploy my-page --dir ./dist
 ```
 
+If the page doesn't exist yet, `deploy` creates it. With an app linked in
+`sweatstack.toml`, it creates that app's page. Without one, it asks to create a
+new app with the page (and fails instead when not run interactively, e.g. in CI).
+
 ## License
 
 MIT

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/README.md

@@ -104,6 +104,10 @@ sweatstack page deploy
 sweatstack page deploy my-page --dir ./dist
 ```
 
+If the page doesn't exist yet, `deploy` creates it. With an app linked in
+`sweatstack.toml`, it creates that app's page. Without one, it asks to create a
+new app with the page (and fails instead when not run interactively, e.g. in CI).
+
 ## License
 
 MIT

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sweatstack-cli"
-version = "0.11.0"
+version = "0.12.0"
 description = "Command-line interface for SweatStack — the sports data platform for developers"
 readme = "README.md"
 authors = [{ name = "Aart Goossens", email = "aart@sweatstack.no" }]

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/src/sweatstack_cli/commands/auth.py

@@ -11,6 +11,16 @@ from sweatstack_cli.exceptions import APIError, AuthenticationError
 from sweatstack_cli.version_check import check_for_update
 
 
+def _display_name(user: dict[str, object]) -> str:
+    """Best human-readable name from an OIDC userinfo response.
+
+    Userinfo carries ``given_name``/``family_name`` (both optional), not ``name``.
+    """
+    parts = [user.get("given_name"), user.get("family_name")]
+    full_name = " ".join(p for p in parts if isinstance(p, str) and p)
+    return full_name or str(user.get("email") or user.get("sub") or "unknown")
+
+
 def login(
     force: bool = typer.Option(
         False,
@@ -30,7 +40,7 @@ def login(
                 client = APIClient(authenticator=auth)
                 user = client.get("/api/v1/oauth/userinfo")
                 console.print(
-                    f"Already logged in as [bold]{user['name']}[/bold]. "
+                    f"Already logged in as [bold]{_display_name(user)}[/bold]. "
                     f"Use [cyan]--force[/cyan] to re-authenticate."
                 )
                 return
@@ -48,7 +58,7 @@ def login(
     try:
         client = APIClient(authenticator=auth)
         user = client.get("/api/v1/oauth/userinfo")
-        console.print(f"[green]✓[/green] Logged in as [bold]{user['name']}[/bold]")
+        console.print(f"[green]✓[/green] Logged in as [bold]{_display_name(user)}[/bold]")
     except AuthenticationError as e:
         console.print(f"[red]Login succeeded but verification failed:[/red] {e}")
         raise typer.Exit(2)
@@ -76,7 +86,7 @@ def status() -> None:
         try:
             client = APIClient(authenticator=auth)
             user = client.get("/api/v1/oauth/userinfo")
-            console.print(f"  Name:   {user.get('name', 'unknown')}")
+            console.print(f"  Name:   {_display_name(user)}")
             console.print(f"  Email:  {user.get('email', 'unknown')}")
             console.print(f"  ID:     {user.get('sub', 'unknown')}")
         except (AuthenticationError, APIError):

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/src/sweatstack_cli/commands/page.py

@@ -33,9 +33,6 @@ from sweatstack_cli.services.applications import (
 PAGES_DOMAIN = "pages.sweatstack.dev"
 DEFAULT_PAGE_TITLE = "SweatStack App"
 
-# URL where users can create pages for their applications
-SETTINGS_URL = "https://app.sweatstack.no/settings/api"
-
 app = typer.Typer(
     name="page",
     help="Deploy static sites to SweatStack Pages.",
@@ -162,45 +159,29 @@ def deploy(
             "Your site may not load correctly."
         )
 
-    try:
-        client = APIClient()
-    except AuthenticationError as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(2)
+    client = _require_client()
 
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console,
-        transient=True,
-    ) as progress:
-        progress.add_task(
-            f"Deploying [bold]{page_slug}[/bold] ({file_count} files)...",
-            total=None,
+    # Update or create: a missing page is created, then the deploy is retried.
+    config_written = False
+    try:
+        result = _upload(client, page_slug, files)
+    except APIError as e:
+        if e.status_code != 404:
+            console.print(f"[red]Error:[/red] {e}")
+            raise typer.Exit(3)
+        page_slug, config_written = _create_missing_page(
+            client, config=config, slug=page_slug, directory=Path(rel_dir)
         )
-
         try:
-            result = client.put(f"/api/v1/pages/{page_slug}/deploy", files=files)
+            result = _upload(client, page_slug, files)
         except APIError as e:
-            error_msg = str(e)
-
-            # Handle 404 - page doesn't exist
-            if "(404)" in error_msg:
-                console.print(f"[red]Error:[/red] Page '{page_slug}' not found.")
-                console.print()
-                console.print(
-                    f"Create this page first at: [link={SETTINGS_URL}]{SETTINGS_URL}[/link]"
-                )
-                console.print()
-                console.print("[dim]Pages must be created in the SweatStack dashboard[/dim]")
-                console.print("[dim]before you can deploy to them.[/dim]")
-                raise typer.Exit(1)
-
             console.print(f"[red]Error:[/red] {e}")
             raise typer.Exit(3)
 
     # Save to config after successful deploy
-    if config:
+    if config_written:
+        pass  # Creating the application wrote sweatstack.toml in full.
+    elif config:
         new_slug = page_slug if not config.page.slug else None
         new_dir = rel_dir if (not config.page.directory and directory_explicit) else None
         if new_slug or new_dir:
@@ -227,6 +208,76 @@ def deploy(
             console.print(f"  {publish_url}")
 
 
+def _upload(
+    client: APIClient, slug: str, files: list[tuple[str, tuple[str, bytes, str]]]
+) -> dict[str, Any]:
+    """Replace the page's files, showing a spinner while uploading."""
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task(f"Deploying [bold]{slug}[/bold] ({len(files)} files)...", total=None)
+        return client.put(f"/api/v1/pages/{slug}/deploy", files=files)
+
+
+def _create_missing_page(
+    client: APIClient,
+    *,
+    config: ProjectConfig | None,
+    slug: str,
+    directory: Path,
+) -> tuple[str, bool]:
+    """Create the page ``deploy`` couldn't find. Returns ``(slug, config_written)``.
+
+    With an application linked in sweatstack.toml, its page is created at ``slug``.
+    Without one, a new application with that page is created after asking (the same
+    flow as ``page init``); non-interactively, that's an error instead.
+    """
+    client_id = config.app.client_id if config else None
+
+    if client_id:
+        try:
+            ensure_page(client, application_id=client_id, slug=slug)
+        except APIError as error:
+            if error.code == APPLICATION_HAS_PAGE_CODE:
+                # One page per app, and a live URL is never renamed.
+                existing = get_page_slug(client, client_id)
+                console.print(
+                    f"[red]Error:[/red] This application's page is "
+                    f"[bold]{existing}[/bold], not [bold]{slug}[/bold]."
+                )
+                console.print(f"[dim]Deploy it with: sweatstack page deploy {existing}[/dim]")
+                raise typer.Exit(1)
+            _exit_slug_error(error, hint="Deploy to a different page name.")
+        console.print(f"[green]✓[/green] Created page [bold]{slug}[/bold]")
+        return slug, False
+
+    if not _is_interactive():
+        console.print(
+            f"[red]Error:[/red] Page '{slug}' not found, and no application is linked "
+            f"in {CONFIG_FILENAME}."
+        )
+        console.print()
+        console.print("Link an existing app (its page is created on the next deploy):")
+        console.print("  [cyan]sweatstack app link[/cyan]")
+        console.print()
+        console.print("Or create a new app with this page:")
+        console.print(f'  [cyan]sweatstack app create "<name>" --page {slug}[/cyan]')
+        raise typer.Exit(1)
+
+    console.print(
+        f"Page [bold]{slug}[/bold] doesn't exist yet, and no application is linked "
+        f"in {CONFIG_FILENAME}."
+    )
+    name = typer.prompt("Application name", default=slug)
+    _client_id, accepted, _url, _name = _init_bootstrap(
+        name=name, slug=slug, directory=directory, interactive=True
+    )
+    return accepted, True
+
+
 def _find_available_port(start: int = 8000, max_attempts: int = 100) -> int:
     """Find the first available port starting from `start`."""
     for port in range(start, start + max_attempts):
@@ -350,11 +401,13 @@ def _slug_rejection_message(error: APIError) -> str:
     return messages.get(error.code or "", error.detail or str(error))
 
 
-def _exit_slug_error(error: APIError) -> NoReturn:
+def _exit_slug_error(
+    error: APIError, *, hint: str = "Choose another name or pass --slug."
+) -> NoReturn:
     """Report a slug-related (or other) API error and exit."""
     if error.code in SLUG_REJECTION_CODES:
         console.print(f"[red]Error:[/red] {_slug_rejection_message(error)}")
-        console.print("[dim]Choose another name or pass --slug.[/dim]")
+        console.print(f"[dim]{hint}[/dim]")
     else:
         console.print(f"[red]Error:[/red] {error}")
     raise typer.Exit(3)

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/src/sweatstack_cli/services/applications.py

@@ -90,9 +90,10 @@ def ensure_page(client: APIClient, *, application_id: str, slug: str) -> dict[st
     ``code == APPLICATION_HAS_PAGE_CODE`` if this application already has a Page
     at a different slug.
     """
+    # The endpoint reads ``slug`` as a form field, not JSON.
     return client.put(
         f"/api/v1/applications/{application_id}/page",
-        json={"slug": slug},
+        data={"slug": slug},
     )
 
 

sweatstack_cli-0.12.0/tests/test_commands/test_auth.py

@@ -0,0 +1,49 @@
+"""Tests for authentication commands."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from typer.testing import CliRunner
+
+from sweatstack_cli.commands.auth import _display_name
+from sweatstack_cli.main import app
+
+runner = CliRunner()
+
+# Shape of GET /api/v1/oauth/userinfo: OIDC claims, no `name`.
+USERINFO = {
+    "sub": "user_123",
+    "given_name": "Ada",
+    "family_name": "Lovelace",
+    "email": "ada@example.com",
+    "registered_at": "2026-01-01T00:00:00Z",
+    "issue": None,
+}
+
+
+class TestDisplayName:
+    def test_joins_given_and_family_name(self) -> None:
+        assert _display_name(USERINFO) == "Ada Lovelace"
+
+    def test_given_name_only(self) -> None:
+        assert _display_name({"sub": "u", "given_name": "Ada", "family_name": None}) == "Ada"
+
+    def test_falls_back_to_email_then_sub(self) -> None:
+        assert _display_name({"sub": "u", "email": "ada@example.com"}) == "ada@example.com"
+        assert _display_name({"sub": "u"}) == "u"
+
+
+class TestLogin:
+    def test_already_logged_in_uses_userinfo_claims(self) -> None:
+        with (
+            patch("sweatstack_cli.commands.auth.Authenticator") as mock_auth,
+            patch("sweatstack_cli.commands.auth.APIClient") as mock_client,
+        ):
+            mock_auth.return_value.get_valid_tokens.return_value = MagicMock()
+            mock_client.return_value.get.return_value = USERINFO
+
+            result = runner.invoke(app, ["login"])
+
+        assert result.exit_code == 0, result.output
+        assert "Already logged in as Ada Lovelace" in result.stdout

sweatstack_cli-0.12.0/tests/test_commands/test_page_deploy.py

@@ -0,0 +1,155 @@
+"""Tests for `page deploy`: update the page, or create it when it doesn't exist."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from sweatstack_cli.exceptions import APIError
+from sweatstack_cli.main import app
+from sweatstack_cli.project import ProjectConfig, write_config
+
+runner = CliRunner()
+
+DEPLOYED = {
+    "slug": "my-page",
+    "published": True,
+    "url": "https://my-page.pages.sweatstack.dev",
+    "application": {"id": "app_123", "name": "My App", "is_private": False},
+}
+NOT_FOUND = APIError("API error (404): Page not found", status_code=404)
+
+
+@pytest.fixture
+def mock_api() -> Iterator[MagicMock]:
+    with patch("sweatstack_cli.commands.page.APIClient") as mock_client:
+        instance = MagicMock()
+        mock_client.return_value = instance
+        yield instance
+
+
+@pytest.fixture
+def site(tmp_path: Path) -> Iterator[Path]:
+    """An isolated working directory with a deployable `public/`."""
+    with runner.isolated_filesystem(temp_dir=tmp_path) as cwd:
+        Path("public").mkdir()
+        Path("public/index.html").write_text("<h1>hi</h1>")
+        yield Path(cwd)
+
+
+def _interactive(value: bool):
+    return patch("sweatstack_cli.commands.page._is_interactive", return_value=value)
+
+
+def _deploy_calls(mock_api: MagicMock) -> list[str]:
+    return [c.args[0] for c in mock_api.put.call_args_list if c.args[0].endswith("/deploy")]
+
+
+class TestDeployExistingPage:
+    def test_deploys_without_creating(self, mock_api: MagicMock, site: Path) -> None:
+        mock_api.put.return_value = DEPLOYED
+
+        result = runner.invoke(app, ["page", "deploy", "my-page", "--dir", "public"])
+
+        assert result.exit_code == 0, result.output
+        mock_api.put.assert_called_once()
+        mock_api.post.assert_not_called()
+
+    def test_other_errors_do_not_create(self, mock_api: MagicMock, site: Path) -> None:
+        mock_api.put.side_effect = APIError("API error (403): Not authorized", status_code=403)
+
+        result = runner.invoke(app, ["page", "deploy", "my-page", "--dir", "public"])
+
+        assert result.exit_code == 3
+        mock_api.put.assert_called_once()
+        mock_api.post.assert_not_called()
+
+
+class TestDeployCreatesPageForLinkedApp:
+    def _link(self) -> None:
+        write_config(
+            app_name="My App", client_id="app_123", page_slug="my-page", page_directory="public"
+        )
+
+    def test_creates_page_then_deploys(self, mock_api: MagicMock, site: Path) -> None:
+        self._link()
+        mock_api.put.side_effect = [NOT_FOUND, {"slug": "my-page"}, DEPLOYED]
+
+        with _interactive(False):
+            result = runner.invoke(app, ["page", "deploy"])
+
+        assert result.exit_code == 0, result.output
+        mock_api.put.assert_any_call("/api/v1/applications/app_123/page", data={"slug": "my-page"})
+        assert _deploy_calls(mock_api) == ["/api/v1/pages/my-page/deploy"] * 2
+        assert "Created page my-page" in result.stdout
+        config = ProjectConfig.load()
+        assert config is not None
+        assert config.app.client_id == "app_123"
+
+    def test_app_with_another_page_is_an_error(self, mock_api: MagicMock, site: Path) -> None:
+        self._link()
+        mock_api.put.side_effect = [
+            NOT_FOUND,
+            APIError("has page", status_code=409, code="application_has_page"),
+        ]
+        mock_api.get.return_value = [{"id": "app_123", "name": "My App", "page_slug": "other"}]
+
+        with _interactive(False):
+            result = runner.invoke(app, ["page", "deploy"])
+
+        assert result.exit_code == 1
+        assert "page is other, not my-page" in result.stdout
+        assert len(_deploy_calls(mock_api)) == 1
+
+
+class TestDeployCreatesAppWhenUnlinked:
+    def test_non_interactive_fails_with_hints(self, mock_api: MagicMock, site: Path) -> None:
+        mock_api.put.side_effect = NOT_FOUND
+
+        with _interactive(False):
+            result = runner.invoke(app, ["page", "deploy", "my-page", "--dir", "public"])
+
+        assert result.exit_code == 1
+        assert "sweatstack app link" in result.stdout
+        assert 'sweatstack app create "<name>" --page my-page' in result.stdout
+        mock_api.post.assert_not_called()
+
+    def test_interactive_creates_app_after_asking(self, mock_api: MagicMock, site: Path) -> None:
+        mock_api.put.side_effect = [NOT_FOUND, DEPLOYED]
+        mock_api.post.return_value = {
+            "id": "app_123",
+            "name": "My App",
+            "page": {"slug": "my-page", "url": "https://my-page.pages.sweatstack.dev"},
+        }
+
+        with _interactive(True):
+            result = runner.invoke(
+                app, ["page", "deploy", "my-page", "--dir", "public"], input="My App\ny\n"
+            )
+
+        assert result.exit_code == 0, result.output
+        mock_api.post.assert_called_once_with(
+            "/api/v1/applications", json={"name": "My App", "page": "my-page"}
+        )
+        assert _deploy_calls(mock_api) == ["/api/v1/pages/my-page/deploy"] * 2
+        config = ProjectConfig.load()
+        assert config is not None
+        assert config.app.client_id == "app_123"
+        assert config.page.slug == "my-page"
+        assert config.page.directory == "public"
+
+    def test_interactive_decline_creates_nothing(self, mock_api: MagicMock, site: Path) -> None:
+        mock_api.put.side_effect = NOT_FOUND
+
+        with _interactive(True):
+            result = runner.invoke(
+                app, ["page", "deploy", "my-page", "--dir", "public"], input="My App\nn\n"
+            )
+
+        assert result.exit_code == 1
+        mock_api.post.assert_not_called()
+        assert not Path("sweatstack.toml").exists()

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/tests/test_commands/test_page_init.py

@@ -195,7 +195,7 @@ class TestReuse:
 
             assert result.exit_code == 0, result.stdout
             mock_api.put.assert_called_once_with(
-                "/api/v1/applications/app_123/page", json={"slug": "my-app"}
+                "/api/v1/applications/app_123/page", data={"slug": "my-app"}
             )
             assert "Created page" in result.stdout
             assert ProjectConfig.load().page.slug == "my-app"  # type: ignore[union-attr]

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/tests/test_services/test_applications.py

@@ -86,7 +86,7 @@ class TestEnsurePage:
         result = ensure_page(client, application_id="abc", slug="my-app")
 
         assert result["slug"] == "my-app"
-        client.put.assert_called_once_with("/api/v1/applications/abc/page", json={"slug": "my-app"})
+        client.put.assert_called_once_with("/api/v1/applications/abc/page", data={"slug": "my-app"})
 
 
 class TestGetPageSlug:

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.0}/uv.lock

@@ -463,7 +463,7 @@ wheels = [
 
 [[package]]
 name = "sweatstack-cli"
-version = "0.11.0"
+version = "0.12.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },