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

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

@@ -4,6 +4,37 @@ 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.1] - 2026-10-13
+
+### Fixed
+
+- 0.12.0 reported itself as 0.11.0: in `--version`, in `status` (which then
+  always offered an "update" to 0.12.0) and in the `User-Agent` header. The
+  version is now read from the installed package, so `pyproject.toml` is the
+  only place to bump it.
+- `app create` checks for an existing `sweatstack.toml` before creating the
+  application, not after. Non-interactively, or when declining to overwrite, it
+  used to create the app and then stop, leaving an application nothing pointed to.
+
+## [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.1}/DEVELOPMENT.md

@@ -25,7 +25,7 @@ pytest
 
 ```
 src/sweatstack_cli/
-├── __init__.py              # Package version
+├── __init__.py              # Package version (read from metadata)
 ├── main.py                  # CLI entry point (Typer app)
 ├── config.py                # Environment-based configuration
 ├── console.py               # Rich console singleton
@@ -338,11 +338,13 @@ def my_command():
 
 ## Release Process
 
-1. Update version in `src/sweatstack_cli/__init__.py`
-2. Update `pyproject.toml` version if needed
-3. Run full test suite: `pytest`
-4. Build: `uv build` or `python -m build`
-5. Publish: `twine upload dist/*`
+1. Bump `version` in `pyproject.toml`, then run `uv lock` to update `uv.lock`.
+   This is the only place the version lives: `__version__` reads it from the
+   installed package.
+2. Rename `## [Unreleased]` in `CHANGELOG.md` to `## [X.Y.Z] - YYYY-MM-DD`.
+3. Run all checks: `make check`
+4. Commit as `Release X.Y.Z`
+5. Build and publish: `make publish`
 
 ## Debugging
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sweatstack-cli
-Version: 0.11.0
+Version: 0.12.1
 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
@@ -67,8 +67,11 @@ uv tool install --reinstall sweatstack-cli
 # Authenticate with SweatStack
 sweatstack login
 
-# Create an app and deploy
-sweatstack app create "My App" --page my-page --env
+# Create an app with a page, and scaffold public/index.html
+sweatstack page init "My App"
+
+# Preview locally, then publish to https://my-app.pages.sweatstack.dev
+sweatstack page serve
 sweatstack page deploy
 ```
 
@@ -110,7 +113,7 @@ sweatstack page deploy
 
 ### Project Configuration
 
-Both `app create` and `app link` generate a `sweatstack.toml` in the current directory. Other commands read defaults from this file.
+`app create`, `app link` and `page init` generate a `sweatstack.toml` in the current directory. Other commands read defaults from this file.
 
 ```toml
 [app]
@@ -122,9 +125,33 @@ slug = "my-page"
 directory = "dist"
 ```
 
-### Page Deployment
+### Pages
+
+Static sites hosted at `https://<slug>.pages.sweatstack.dev`. Each application has at most one page.
+
+| Command | Description |
+|---------|-------------|
+| `sweatstack page init [NAME]` | Create an app and its page, and scaffold `public/index.html` |
+| `sweatstack page serve` | Preview the site locally |
+| `sweatstack page deploy [SLUG]` | Publish the site, creating the page if needed |
+
+#### `page init`
 
-Deploy static sites to SweatStack Pages.
+Creates a private application and its page, records both in `sweatstack.toml`, and writes a starter app to `public/index.html` that signs in with SweatStack and plots your latest activity. The slug is derived from the name. With an app already linked in `sweatstack.toml`, it reuses that app instead of creating one.
+
+| Option | Description |
+|--------|-------------|
+| `--slug TEXT` | Page slug (default: derived from the name) |
+| `--dir PATH` | Directory to scaffold (default: `public`) |
+| `--title TEXT` | Title shown on the page (default: the name) |
+| `--client-id TEXT` | Reuse an existing application |
+| `--force, -f` | Overwrite an existing `index.html` |
+
+#### `page serve`
+
+Serves the `[page] directory` from `sweatstack.toml` on the first free port from 8000. Extra arguments are passed to `python -m http.server`. Apps created by the CLI accept sign-in redirects to localhost on any port.
+
+#### `page deploy`
 
 ```bash
 # Deploy using sweatstack.toml defaults (recommended)
@@ -134,6 +161,12 @@ sweatstack page deploy
 sweatstack page deploy my-page --dir ./dist
 ```
 
+Every deploy replaces all files on the page. 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).
+
+New apps are private: only you can sign in. After deploying, `deploy` prints a link to make the app public.
+
+**Limits:** 10 MB per file; 100 MB and about 1,000 files per deploy.
+
 ## License
 
 MIT

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

@@ -37,8 +37,11 @@ uv tool install --reinstall sweatstack-cli
 # Authenticate with SweatStack
 sweatstack login
 
-# Create an app and deploy
-sweatstack app create "My App" --page my-page --env
+# Create an app with a page, and scaffold public/index.html
+sweatstack page init "My App"
+
+# Preview locally, then publish to https://my-app.pages.sweatstack.dev
+sweatstack page serve
 sweatstack page deploy
 ```
 
@@ -80,7 +83,7 @@ sweatstack page deploy
 
 ### Project Configuration
 
-Both `app create` and `app link` generate a `sweatstack.toml` in the current directory. Other commands read defaults from this file.
+`app create`, `app link` and `page init` generate a `sweatstack.toml` in the current directory. Other commands read defaults from this file.
 
 ```toml
 [app]
@@ -92,9 +95,33 @@ slug = "my-page"
 directory = "dist"
 ```
 
-### Page Deployment
+### Pages
+
+Static sites hosted at `https://<slug>.pages.sweatstack.dev`. Each application has at most one page.
+
+| Command | Description |
+|---------|-------------|
+| `sweatstack page init [NAME]` | Create an app and its page, and scaffold `public/index.html` |
+| `sweatstack page serve` | Preview the site locally |
+| `sweatstack page deploy [SLUG]` | Publish the site, creating the page if needed |
+
+#### `page init`
 
-Deploy static sites to SweatStack Pages.
+Creates a private application and its page, records both in `sweatstack.toml`, and writes a starter app to `public/index.html` that signs in with SweatStack and plots your latest activity. The slug is derived from the name. With an app already linked in `sweatstack.toml`, it reuses that app instead of creating one.
+
+| Option | Description |
+|--------|-------------|
+| `--slug TEXT` | Page slug (default: derived from the name) |
+| `--dir PATH` | Directory to scaffold (default: `public`) |
+| `--title TEXT` | Title shown on the page (default: the name) |
+| `--client-id TEXT` | Reuse an existing application |
+| `--force, -f` | Overwrite an existing `index.html` |
+
+#### `page serve`
+
+Serves the `[page] directory` from `sweatstack.toml` on the first free port from 8000. Extra arguments are passed to `python -m http.server`. Apps created by the CLI accept sign-in redirects to localhost on any port.
+
+#### `page deploy`
 
 ```bash
 # Deploy using sweatstack.toml defaults (recommended)
@@ -104,6 +131,12 @@ sweatstack page deploy
 sweatstack page deploy my-page --dir ./dist
 ```
 
+Every deploy replaces all files on the page. 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).
+
+New apps are private: only you can sign in. After deploying, `deploy` prints a link to make the app public.
+
+**Limits:** 10 MB per file; 100 MB and about 1,000 files per deploy.
+
 ## License
 
 MIT

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

@@ -1,6 +1,6 @@
 [project]
 name = "sweatstack-cli"
-version = "0.11.0"
+version = "0.12.1"
 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.12.1/src/sweatstack_cli/__init__.py

@@ -0,0 +1,10 @@
+"""SweatStack CLI — Command-line interface for the SweatStack platform."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+# Single source of truth: the version in pyproject.toml, read from the installed
+# package's metadata. A hardcoded copy here drifted once (0.12.0 shipped as 0.11.0).
+try:
+    __version__ = version("sweatstack-cli")
+except PackageNotFoundError:  # Imported from a source tree that isn't installed.
+    __version__ = "unknown"

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.1}/src/sweatstack_cli/commands/app.py

@@ -74,6 +74,18 @@ def create(
             raise typer.Exit(1)
         name = typer.prompt("App name")
 
+    # Protect an existing sweatstack.toml before creating anything, so declining
+    # (or a non-interactive refusal) never leaves an orphaned application behind.
+    if Path(CONFIG_FILENAME).exists():
+        if not interactive:
+            console.print(
+                f"[red]Error:[/red] {CONFIG_FILENAME} already exists. "
+                "Remove it first or run interactively."
+            )
+            raise typer.Exit(1)
+        console.print(f"[yellow]Warning:[/yellow] {CONFIG_FILENAME} already exists.")
+        typer.confirm("Overwrite?", abort=True)
+
     # Prompt for optional fields in interactive mode
     if interactive:
         if description is None:
@@ -110,18 +122,7 @@ def create(
     if env_path:
         _write_env_file(env_path, result)
 
-    # Write sweatstack.toml (protect existing file)
-    config_path = Path(CONFIG_FILENAME)
-    if config_path.exists():
-        if not interactive:
-            console.print(
-                f"[red]Error:[/red] {CONFIG_FILENAME} already exists. "
-                "Remove it first or run interactively."
-            )
-            raise typer.Exit(1)
-        console.print(f"[yellow]Warning:[/yellow] {CONFIG_FILENAME} already exists.")
-        typer.confirm("Overwrite?", abort=True)
-
+    # Write sweatstack.toml (checked for overwrite before the app was created)
     # Default the deploy directory to public/ so the project is deploy-ready and
     # consistent with `page init` / `page serve` / `page deploy`.
     config_path = write_config(

{sweatstack_cli-0.11.0 → sweatstack_cli-0.12.1}/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.1}/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.1}/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.11.0 → sweatstack_cli-0.12.1}/tests/test_commands/test_app.py

@@ -189,9 +189,12 @@ class TestAppCreate:
         assert result.exit_code == 1
         assert "mutually exclusive" in result.stdout
 
-    def test_create_not_authenticated(self) -> None:
+    def test_create_not_authenticated(self, tmp_path: Path) -> None:
         """Should error when not authenticated."""
-        with patch("sweatstack_cli.commands.app.APIClient") as mock_client:
+        with (
+            patch("sweatstack_cli.commands.app.APIClient") as mock_client,
+            runner.isolated_filesystem(temp_dir=tmp_path),
+        ):
             mock_client.side_effect = AuthenticationError("Not authenticated")
 
             result = runner.invoke(app, ["app", "create", "Test App"])
@@ -200,15 +203,30 @@ class TestAppCreate:
             assert "Not authenticated" in result.stdout
             assert "sweatstack login" in result.stdout
 
-    def test_create_api_error(self, mock_api: MagicMock) -> None:
+    def test_create_api_error(self, mock_api: MagicMock, tmp_path: Path) -> None:
         """Should handle API errors."""
         mock_api.post.side_effect = APIError("App name already exists")
 
-        result = runner.invoke(app, ["app", "create", "Test App"])
+        with runner.isolated_filesystem(temp_dir=tmp_path):
+            result = runner.invoke(app, ["app", "create", "Test App"])
 
         assert result.exit_code == 3
         assert "App name already exists" in result.stdout
 
+    def test_create_existing_config_creates_nothing(
+        self, mock_api: MagicMock, tmp_path: Path
+    ) -> None:
+        """Should refuse before creating the app, never leaving an orphan behind."""
+        with runner.isolated_filesystem(temp_dir=tmp_path):
+            Path("sweatstack.toml").write_text('[app]\nclient_id = "existing"\n')
+
+            result = runner.invoke(app, ["app", "create", "Test App"])
+
+            assert result.exit_code == 1
+            assert "already exists" in result.stdout
+            mock_api.post.assert_not_called()
+            assert Path("sweatstack.toml").read_text() == '[app]\nclient_id = "existing"\n'
+
     def test_create_env_with_secret_no_warning_without_env(
         self, mock_api: MagicMock, tmp_path: Path
     ) -> None:

sweatstack_cli-0.12.1/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.1/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.1}/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.1}/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.12.1/tests/test_version.py

@@ -0,0 +1,17 @@
+"""The reported version is the one in pyproject.toml."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+
+from sweatstack_cli import __version__
+
+PYPROJECT = Path(__file__).parent.parent / "pyproject.toml"
+
+
+def test_version_matches_pyproject() -> None:
+    with PYPROJECT.open("rb") as f:
+        expected = tomllib.load(f)["project"]["version"]
+
+    assert __version__ == expected

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

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

sweatstack_cli-0.11.0/src/sweatstack_cli/__init__.py

@@ -1,3 +0,0 @@
-"""SweatStack CLI — Command-line interface for the SweatStack platform."""
-
-__version__ = "0.11.0"