softmax-cli 0.23.0__tar.gz → 0.25.0__tar.gz

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softmax-cli
-Version: 0.23.0
+Version: 0.25.0
 Summary: Softmax CLI — authentication and account tools
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
@@ -12,3 +12,5 @@ Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.34.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: cogames
+Requires-Dist: cogames; extra == "cogames"

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/pyproject.toml

@@ -18,6 +18,9 @@ dependencies = [
 ]
 dynamic = ["version"]
 
+[project.optional-dependencies]
+cogames = ["cogames"]
+
 [project.scripts]
 softmax = "softmax.cli:app"
 

softmax_cli-0.25.0/src/softmax/__init__.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import importlib
+import sys
+from pkgutil import extend_path
+
+from softmax.auth import (
+    DEFAULT_COGAMES_SERVER,
+    load_cogames_user_token,
+    save_cogames_active_token,
+)
+from softmax.perform_login import do_interactive_login_for_token
+from softmax.token_storage import TokenKind
+
+__path__ = extend_path(__path__, __name__)
+
+
+def login(
+    *,
+    login_server: str = DEFAULT_COGAMES_SERVER,
+    force: bool = False,
+    open_browser: bool = True,
+) -> str:
+    token = None if force else load_cogames_user_token(login_server=login_server)
+    if token is not None:
+        save_cogames_active_token(login_server=login_server, token=token)
+        return token
+
+    if not sys.stdin.isatty():
+        raise RuntimeError(
+            "No saved Softmax token found and interactive login requires a TTY. "
+            "Run `softmax login` or `softmax set-token` first."
+        )
+
+    do_interactive_login_for_token(
+        login_server=login_server,
+        server_to_save_token_under=login_server,
+        token_kind=TokenKind.COGAMES_USER,
+        agent_hint=(
+            "If you are a coding agent, ask your human to open the URL below and give you "
+            "the auth token. Then paste the token into this window or run:\n"
+            "\n"
+            "softmax set-token '<TOKEN>'"
+        ),
+        open_browser=open_browser,
+    )
+
+    token = load_cogames_user_token(login_server=login_server)
+    if token is None:
+        raise RuntimeError(f"Interactive login did not save a token for {login_server}")
+    save_cogames_active_token(login_server=login_server, token=token)
+    return token
+
+
+def __getattr__(name: str) -> object:
+    if name == "cogames":
+        return importlib.import_module("softmax.cogames")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["login", "cogames"]

softmax_cli-0.25.0/src/softmax/auth.py

@@ -0,0 +1,98 @@
+"""Token storage and browser URL helpers for CLI auth."""
+
+from __future__ import annotations
+
+from urllib.parse import urlencode, urlsplit, urlunsplit
+
+import httpx
+from pydantic import BaseModel, Field
+
+from softmax.token_storage import TokenKind
+from softmax.token_storage import delete_token as delete_stored_token
+from softmax.token_storage import load_token as load_saved_token
+from softmax.token_storage import save_token as save_stored_token
+
+DEFAULT_COGAMES_SERVER = "https://softmax.com/api"
+DEFAULT_COGAMES_API_SERVER = "https://api.observatory.softmax-research.net"
+
+
+class WhoAmIResponse(BaseModel):
+    user_email: str
+    is_softmax_team_member: bool = False
+    is_softmax_admin: bool = False
+    subject_type: str = "user"
+    subject_id: str | None = None
+    owner_user_id: str | None = None
+    scopes: list[str] = Field(default_factory=list)
+
+
+def build_browser_login_url(login_server: str, *, callback_url: str | None = None) -> str:
+    """Build the hosted browser sign-in URL for CLI login."""
+    params: dict[str, str] = {}
+    if callback_url:
+        params["callback"] = callback_url
+
+    query = urlencode(params)
+    parsed = urlsplit(login_server)
+    browser_path = parsed.path.rstrip("/").removesuffix("/api") + "/cli-login"
+    return urlunsplit((parsed.scheme, parsed.netloc, browser_path, query, ""))
+
+
+def load_token(*, token_kind: TokenKind, server: str) -> str | None:
+    return load_saved_token(token_kind=token_kind, server=server)
+
+
+def has_saved_token(*, token_kind: TokenKind, server: str) -> bool:
+    return load_token(token_kind=token_kind, server=server) is not None
+
+
+def save_token(*, token_kind: TokenKind, server: str, token: str) -> None:
+    save_stored_token(token_kind=token_kind, server=server, token=token)
+
+
+def delete_token(*, token_kind: TokenKind, server: str) -> bool:
+    return delete_stored_token(token_kind=token_kind, server=server)
+
+
+def load_cogames_user_token(*, login_server: str) -> str | None:
+    return load_token(token_kind=TokenKind.COGAMES_USER, server=login_server)
+
+
+def load_current_cogames_token(*, login_server: str) -> str | None:
+    return load_token(token_kind=TokenKind.COGAMES, server=login_server) or load_cogames_user_token(
+        login_server=login_server
+    )
+
+
+def save_cogames_active_token(*, login_server: str, token: str) -> None:
+    save_token(token_kind=TokenKind.COGAMES, server=login_server, token=token)
+
+
+def save_cogames_user_token(*, login_server: str, token: str) -> None:
+    save_token(token_kind=TokenKind.COGAMES_USER, server=login_server, token=token)
+    save_cogames_active_token(login_server=login_server, token=token)
+
+
+def delete_cogames_tokens(*, login_server: str) -> bool:
+    deleted_active = delete_token(token_kind=TokenKind.COGAMES, server=login_server)
+    deleted_user = delete_token(token_kind=TokenKind.COGAMES_USER, server=login_server)
+    return deleted_active or deleted_user
+
+
+def fetch_cogames_whoami(*, api_server: str | None = None, token: str) -> WhoAmIResponse:
+    server = api_server or DEFAULT_COGAMES_API_SERVER
+    response = httpx.get(
+        f"{server.rstrip('/')}/whoami",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10.0,
+    )
+    response.raise_for_status()
+    return WhoAmIResponse.model_validate(response.json())
+
+
+def restore_cogames_user_session(*, login_server: str) -> str | None:
+    user_token = load_cogames_user_token(login_server=login_server)
+    if user_token is None:
+        return None
+    save_cogames_active_token(login_server=login_server, token=user_token)
+    return user_token

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/src/softmax/cli.py

@@ -1,8 +1,9 @@
 """softmax CLI — authentication and account tools."""
 
+import importlib
+import importlib.util
 import sys
 
-import httpx
 import typer
 from rich.panel import Panel
 
@@ -10,10 +11,12 @@ from softmax._console import console
 from softmax.auth import (
     DEFAULT_COGAMES_SERVER,
     build_browser_login_url,
-    delete_token,
-    has_saved_token,
-    load_token,
-    save_token,
+    delete_cogames_tokens,
+    fetch_cogames_whoami,
+    load_cogames_user_token,
+    load_current_cogames_token,
+    save_cogames_active_token,
+    save_cogames_user_token,
 )
 from softmax.perform_login import do_interactive_login_for_token
 from softmax.token_storage import TokenKind
@@ -26,6 +29,14 @@ app = typer.Typer(
 )
 
 
+def _register_optional_apps() -> None:
+    if importlib.util.find_spec("cogames.softmax_cli") is None:
+        return
+
+    cogames_cli = importlib.import_module("cogames.softmax_cli")
+    app.add_typer(cogames_cli.app, name="cogames", rich_help_panel="Local Games")
+
+
 def _build_manual_set_token_command(*, login_server: str) -> str:
     command = "softmax set-token '<TOKEN>'"
     if login_server != DEFAULT_COGAMES_SERVER:
@@ -78,7 +89,9 @@ def login_cmd(
     """Sign in to Softmax."""
     from urllib.parse import urlparse  # noqa: PLC0415
 
-    if has_saved_token(token_kind=TokenKind.COGAMES, server=login_server) and not force:
+    user_token = None if force else load_cogames_user_token(login_server=login_server)
+    if user_token is not None:
+        save_cogames_active_token(login_server=login_server, token=user_token)
         console.print(f"Already authenticated with {urlparse(login_server).hostname}", style="green")
         return
 
@@ -90,7 +103,7 @@ def login_cmd(
         do_interactive_login_for_token(
             login_server=login_server,
             server_to_save_token_under=login_server,
-            token_kind=TokenKind.COGAMES,
+            token_kind=TokenKind.COGAMES_USER,
             agent_hint=(
                 "If you are a coding agent, ask your human to open the URL below and give you "
                 "the auth token. Then paste the token into this window or run:\n"
@@ -105,6 +118,9 @@ def login_cmd(
         console.print("Authentication failed.", style="red")
         raise typer.Exit(1) from e
 
+    user_token = load_cogames_user_token(login_server=login_server)
+    assert user_token is not None
+    save_cogames_active_token(login_server=login_server, token=user_token)
     console.print("Authentication successful.", style="green")
 
 
@@ -118,7 +134,7 @@ def logout_cmd(
     ),
 ) -> None:
     """Remove saved authentication token."""
-    if delete_token(token_kind=TokenKind.COGAMES, server=login_server):
+    if delete_cogames_tokens(login_server=login_server):
         console.print("Logged out.", style="green")
     else:
         console.print("No token found — already logged out.", style="yellow")
@@ -145,21 +161,28 @@ def status_cmd(
         metavar="URL",
         help="Authentication server URL",
     ),
+    server: str | None = typer.Option(
+        None,
+        "--server",
+        "-s",
+        metavar="URL",
+        help="API server URL for /whoami verification. Defaults to --login-server when"
+        " that is overridden, otherwise the production Observatory API.",
+    ),
 ) -> None:
     """Check authentication status via /whoami."""
-    token = load_token(token_kind=TokenKind.COGAMES, server=login_server)
+    token = load_current_cogames_token(login_server=login_server)
     if not token:
         console.print("[red]Not authenticated.[/red] Run [cyan]softmax login[/cyan] first.")
         raise typer.Exit(1)
 
-    response = httpx.get(
-        f"{login_server.rstrip('/')}/whoami",
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=10.0,
-    )
-    response.raise_for_status()
-    email = response.json().get("user_email", "unknown")
-    console.print(f"[green]Authenticated as {email}[/green]")
+    api_server = server or (login_server if login_server != DEFAULT_COGAMES_SERVER else None)
+    session = fetch_cogames_whoami(api_server=api_server, token=token)
+    console.print("[green]Authenticated[/green]")
+    console.print(f"user_email: {session.user_email}")
+    console.print(f"subject_type: {session.subject_type}")
+    console.print(f"subject_id: {session.subject_id or '-'}")
+    console.print(f"owner_user_id: {session.owner_user_id or '-'}")
 
 
 @app.command(name="get-token")
@@ -172,7 +195,7 @@ def get_token_cmd(
     ),
 ) -> None:
     """Print the saved token to stdout (for scripting)."""
-    token = load_token(token_kind=TokenKind.COGAMES, server=login_server)
+    token = load_current_cogames_token(login_server=login_server)
     if not token:
         console.print("[red]No token found.[/red] Run [cyan]softmax login[/cyan] first.", style="bold")
         raise typer.Exit(1)
@@ -190,5 +213,8 @@ def set_token_cmd(
     ),
 ) -> None:
     """Manually set a token (for CI or headless environments)."""
-    save_token(token_kind=TokenKind.COGAMES, token=token, server=login_server)
+    save_cogames_user_token(login_server=login_server, token=token)
     print(f"\nToken saved for {login_server}")
+
+
+_register_optional_apps()

softmax_cli-0.25.0/src/softmax/cogames.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+from softmax.auth import DEFAULT_COGAMES_API_SERVER, DEFAULT_COGAMES_SERVER
+
+
+def _get_tournament_client_class() -> type[Any]:
+    try:
+        tournament_client_module = importlib.import_module("cogames.cli.client")
+    except ModuleNotFoundError as exc:
+        raise RuntimeError(
+            "softmax.cogames requires the `cogames` package. Install `softmax-cli[cogames]` or `cogames`."
+        ) from exc
+    return tournament_client_module.TournamentServerClient
+
+
+def _create_client(*, token: str, server: str, login_server: str) -> Any:
+    client_class = _get_tournament_client_class()
+    return client_class(server_url=server, token=token, login_server=login_server)
+
+
+class _PlayerAPI:
+    def list(
+        self,
+        token: str,
+        *,
+        server: str = DEFAULT_COGAMES_API_SERVER,
+        login_server: str = DEFAULT_COGAMES_SERVER,
+    ) -> list[Any]:
+        with _create_client(token=token, server=server, login_server=login_server) as client:
+            return client.list_players()
+
+
+player = _PlayerAPI()
+
+
+def login(
+    token: str,
+    player_id: str,
+    *,
+    server: str = DEFAULT_COGAMES_API_SERVER,
+    login_server: str = DEFAULT_COGAMES_SERVER,
+) -> str:
+    with _create_client(token=token, server=server, login_server=login_server) as client:
+        return client.login_player(player_id).token
+
+
+def login_response(
+    token: str,
+    player_id: str,
+    *,
+    server: str = DEFAULT_COGAMES_API_SERVER,
+    login_server: str = DEFAULT_COGAMES_SERVER,
+) -> Any:
+    with _create_client(token=token, server=server, login_server=login_server) as client:
+        return client.login_player(player_id)
+
+
+__all__ = ["player", "login", "login_response"]

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/src/softmax/token_storage.py

@@ -7,11 +7,12 @@ import yaml
 
 class TokenKind(StrEnum):
     COGAMES = "cogames"
+    COGAMES_USER = "cogames_user"
     OBSERVATORY = "observatory"
 
 
 def _token_file_name(*, token_kind: TokenKind) -> str:
-    if token_kind == TokenKind.COGAMES:
+    if token_kind in {TokenKind.COGAMES, TokenKind.COGAMES_USER}:
         return "cogames.yaml"
     if token_kind == TokenKind.OBSERVATORY:
         return "config.yaml"
@@ -21,6 +22,8 @@ def _token_file_name(*, token_kind: TokenKind) -> str:
 def _token_storage_key(*, token_kind: TokenKind) -> str | None:
     if token_kind == TokenKind.COGAMES:
         return "login_tokens"
+    if token_kind == TokenKind.COGAMES_USER:
+        return "user_tokens"
     if token_kind == TokenKind.OBSERVATORY:
         return "observatory_tokens"
     raise AssertionError(f"Unhandled token kind: {token_kind}")

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/src/softmax_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softmax-cli
-Version: 0.23.0
+Version: 0.25.0
 Summary: Softmax CLI — authentication and account tools
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
@@ -12,3 +12,5 @@ Requires-Dist: fastapi>=0.115.0
 Requires-Dist: uvicorn>=0.34.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: cogames
+Requires-Dist: cogames; extra == "cogames"

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/src/softmax_cli.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ src/softmax/__init__.py
 src/softmax/_console.py
 src/softmax/auth.py
 src/softmax/cli.py
+src/softmax/cogames.py
 src/softmax/perform_login.py
 src/softmax/token_storage.py
 src/softmax_cli.egg-info/PKG-INFO
@@ -11,4 +12,6 @@ src/softmax_cli.egg-info/dependency_links.txt
 src/softmax_cli.egg-info/entry_points.txt
 src/softmax_cli.egg-info/requires.txt
 src/softmax_cli.egg-info/top_level.txt
-tests/test_auth_login.py
+tests/test_auth_login.py
+tests/test_cli_plugins.py
+tests/test_python_api.py

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/src/softmax_cli.egg-info/requires.txt

@@ -4,3 +4,6 @@ fastapi>=0.115.0
 uvicorn>=0.34.0
 httpx>=0.28.1
 pyyaml>=6.0.2
+
+[cogames]
+cogames

{softmax_cli-0.23.0 → softmax_cli-0.25.0}/tests/test_auth_login.py

@@ -4,10 +4,11 @@ import builtins
 import sys
 
 import pytest
+from typer.testing import CliRunner
 
 import softmax.perform_login as auth_module
 from softmax.auth import build_browser_login_url, load_token
-from softmax.cli import _build_manual_set_token_command
+from softmax.cli import _build_manual_set_token_command, app
 from softmax.perform_login import do_interactive_login_for_token
 from softmax.token_storage import TokenKind, save_token
 
@@ -15,6 +16,7 @@ COGAMES_AGENT_HINT = (
     "🤖 If you are a coding agent, ask your human to open the URL above and give you the resulting auth token. "
     "You can paste the token into this window or run: softmax set-token '<TOKEN>'"
 )
+runner = CliRunner()
 
 
 def test_authenticate_accepts_pasted_token(
@@ -218,6 +220,37 @@ def test_build_browser_login_url_uses_cli_login_path() -> None:
     )
 
 
+def test_status_prints_active_subject_details(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    save_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api", token="player-session-token")
+
+    class FakeResponse:
+        def raise_for_status(self) -> None:
+            return None
+
+        def json(self) -> dict[str, object]:
+            return {
+                "user_email": "regular@example.com",
+                "is_softmax_team_member": False,
+                "is_softmax_admin": False,
+                "subject_type": "player",
+                "subject_id": "ply_alpha",
+                "owner_user_id": "regular@example.com",
+                "scopes": [],
+            }
+
+    monkeypatch.setattr("softmax.auth.httpx.get", lambda *args, **kwargs: FakeResponse())
+
+    result = runner.invoke(app, ["status"])
+    assert result.exit_code == 0
+    assert "subject_type: player" in result.stdout
+    assert "subject_id: ply_alpha" in result.stdout
+    assert "owner_user_id: regular@example.com" in result.stdout
+
+
 def test_interactive_login_requires_tty(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

softmax_cli-0.25.0/tests/test_cli_plugins.py

@@ -0,0 +1,24 @@
+from typer.testing import CliRunner
+
+from softmax.cli import app
+
+runner = CliRunner()
+
+
+def test_softmax_help_lists_cogames_command() -> None:
+    result = runner.invoke(app, ["--help"])
+
+    assert result.exit_code == 0
+    assert "cogames" in result.stdout
+
+
+def test_softmax_cogames_help_lists_local_commands() -> None:
+    result = runner.invoke(app, ["cogames", "--help"])
+
+    assert result.exit_code == 0
+    assert "play" in result.stdout
+    assert "train" in result.stdout
+    assert "eval" in result.stdout
+    assert "bundle" in result.stdout
+    assert "player" in result.stdout
+    assert "tutorial" in result.stdout

softmax_cli-0.25.0/tests/test_python_api.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import importlib
+import sys
+from typing import Any, cast
+
+import pytest
+
+import softmax
+import softmax.cogames as softmax_cogames
+from softmax.auth import load_token
+from softmax.token_storage import TokenKind, save_token
+
+
+def test_login_returns_saved_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="saved-token")
+
+    called = {"interactive": False}
+    monkeypatch.setattr(
+        "softmax.do_interactive_login_for_token",
+        lambda **_: called.__setitem__("interactive", True),
+    )
+
+    assert softmax.login() == "saved-token"
+    assert load_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api") == "saved-token"
+    assert called["interactive"] is False
+
+
+def test_login_runs_interactive_flow_when_missing_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+
+    def fake_login(**_: object) -> None:
+        save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="fresh-token")
+
+    monkeypatch.setattr("softmax.do_interactive_login_for_token", fake_login)
+
+    assert softmax.login() == "fresh-token"
+    assert load_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api") == "fresh-token"
+
+
+def test_login_ignores_active_only_token_without_saved_user_session(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    save_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api", token="active-only-token")
+
+    called = {"interactive": False}
+
+    def fake_login(**_: object) -> None:
+        called["interactive"] = True
+        save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="fresh-token")
+
+    monkeypatch.setattr("softmax.do_interactive_login_for_token", fake_login)
+
+    assert softmax.login() == "fresh-token"
+    assert load_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api") == "fresh-token"
+    assert called["interactive"] is True
+
+
+def test_login_requires_tty_when_missing_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+
+    with pytest.raises(RuntimeError, match="interactive login requires a TTY"):
+        softmax.login()
+
+
+def test_softmax_module_exposes_cogames_submodule() -> None:
+    assert cast(Any, softmax).cogames is importlib.import_module("softmax.cogames")
+
+
+def test_softmax_cogames_player_list_uses_expected_defaults(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict[str, object] = {}
+
+    class FakeClient:
+        def __init__(self, *, server_url: str, token: str, login_server: str) -> None:
+            captured["server_url"] = server_url
+            captured["token"] = token
+            captured["login_server"] = login_server
+
+        def __enter__(self) -> "FakeClient":
+            return self
+
+        def __exit__(self, exc_type, exc, tb) -> None:
+            return None
+
+        def list_players(self) -> list[str]:
+            return ["alpha", "beta"]
+
+    monkeypatch.setattr(softmax_cogames, "_get_tournament_client_class", lambda: FakeClient)
+
+    assert cast(Any, softmax).cogames.player.list("softmax-token") == ["alpha", "beta"]
+    assert captured == {
+        "server_url": "https://api.observatory.softmax-research.net",
+        "token": "softmax-token",
+        "login_server": "https://softmax.com/api",
+    }
+
+
+def test_softmax_cogames_login_returns_player_token(monkeypatch: pytest.MonkeyPatch) -> None:
+    class FakeLoginResponse:
+        token = "player-token"
+
+    class FakeClient:
+        def __init__(self, *, server_url: str, token: str, login_server: str) -> None:
+            self.server_url = server_url
+            self.token = token
+            self.login_server = login_server
+
+        def __enter__(self) -> "FakeClient":
+            return self
+
+        def __exit__(self, exc_type, exc, tb) -> None:
+            return None
+
+        def login_player(self, player_id: str) -> FakeLoginResponse:
+            assert self.server_url == "https://api.observatory.softmax-research.net"
+            assert self.token == "softmax-token"
+            assert self.login_server == "https://softmax.com/api"
+            assert player_id == "ply_alpha"
+            return FakeLoginResponse()
+
+    monkeypatch.setattr(softmax_cogames, "_get_tournament_client_class", lambda: FakeClient)
+
+    assert cast(Any, softmax).cogames.login("softmax-token", "ply_alpha") == "player-token"
+
+
+def test_softmax_cogames_login_response_returns_full_response(monkeypatch: pytest.MonkeyPatch) -> None:
+    class FakeLoginResponse:
+        token = "player-token"
+        expires_at = "2026-02-21T12:00:00Z"
+
+    class FakeClient:
+        def __init__(self, *, server_url: str, token: str, login_server: str) -> None:
+            pass
+
+        def __enter__(self) -> "FakeClient":
+            return self
+
+        def __exit__(self, exc_type, exc, tb) -> None:
+            return None
+
+        def login_player(self, player_id: str) -> FakeLoginResponse:
+            assert player_id == "ply_alpha"
+            return FakeLoginResponse()
+
+    monkeypatch.setattr(softmax_cogames, "_get_tournament_client_class", lambda: FakeClient)
+
+    response = cast(Any, softmax).cogames.login_response("softmax-token", "ply_alpha")
+    assert response.token == "player-token"
+    assert response.expires_at == "2026-02-21T12:00:00Z"
+
+
+def test_login_can_force_refresh_existing_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="old-token")
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+
+    def fake_login(**_: object) -> None:
+        save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="new-token")
+
+    monkeypatch.setattr("softmax.do_interactive_login_for_token", fake_login)
+
+    assert softmax.login(force=True) == "new-token"
+    assert load_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api") == "new-token"
+
+
+def test_login_restores_saved_user_session_over_active_player_session(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    save_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api", token="player-token")
+    save_token(token_kind=TokenKind.COGAMES_USER, server="https://softmax.com/api", token="user-token")
+
+    called = {"interactive": False}
+    monkeypatch.setattr(
+        "softmax.do_interactive_login_for_token",
+        lambda **_: called.__setitem__("interactive", True),
+    )
+
+    assert softmax.login() == "user-token"
+    assert load_token(token_kind=TokenKind.COGAMES, server="https://softmax.com/api") == "user-token"
+    assert called["interactive"] is False

softmax_cli-0.23.0/src/softmax/auth.py

@@ -1,40 +0,0 @@
-"""Token storage and browser URL helpers for CLI auth."""
-
-from __future__ import annotations
-
-from urllib.parse import urlencode, urlsplit, urlunsplit
-
-from softmax.token_storage import TokenKind
-from softmax.token_storage import delete_token as delete_stored_token
-from softmax.token_storage import load_token as load_saved_token
-from softmax.token_storage import save_token as save_stored_token
-
-DEFAULT_COGAMES_SERVER = "https://softmax.com/api"
-
-
-def build_browser_login_url(login_server: str, *, callback_url: str | None = None) -> str:
-    """Build the hosted browser sign-in URL for CLI login."""
-    params: dict[str, str] = {}
-    if callback_url:
-        params["callback"] = callback_url
-
-    query = urlencode(params)
-    parsed = urlsplit(login_server)
-    browser_path = parsed.path.rstrip("/").removesuffix("/api") + "/cli-login"
-    return urlunsplit((parsed.scheme, parsed.netloc, browser_path, query, ""))
-
-
-def load_token(*, token_kind: TokenKind, server: str) -> str | None:
-    return load_saved_token(token_kind=token_kind, server=server)
-
-
-def has_saved_token(*, token_kind: TokenKind, server: str) -> bool:
-    return load_token(token_kind=token_kind, server=server) is not None
-
-
-def save_token(*, token_kind: TokenKind, server: str, token: str) -> None:
-    save_stored_token(token_kind=token_kind, server=server, token=token)
-
-
-def delete_token(*, token_kind: TokenKind, server: str) -> bool:
-    return delete_stored_token(token_kind=token_kind, server=server)