softmax-cli 0.26.18__tar.gz → 0.26.20__tar.gz

softmax_cli-0.26.20/AGENTS.md

@@ -0,0 +1,61 @@
+# AGENTS.md — softmax-cli
+
+The `softmax` CLI: authentication and account tools for Softmax/Observatory. Other packages (e.g. `coworld`) depend on
+it for login/token handling and pin an exact version. Deps: `typer`, `rich`, `httpx`, plus `fastapi`/`uvicorn` for the
+local browser-login callback server. Published to PyPI.
+
+## CLI
+
+Installs a `softmax` entrypoint (`softmax.cli:app`, Typer):
+
+```bash
+uv run softmax login          # browser-based login (spins up a local callback server)
+uv run softmax logout
+uv run softmax status
+uv run softmax get-login-url
+uv run softmax get-token / set-token
+uv run softmax player list / use <player-id> / unset
+```
+
+`softmax player use <player-id>` mints (or reuses) a 24h player session and stores it as the active player in
+`~/.softmax/credentials.yaml` (`player_sessions`). Every auth-backed command in any CLI built on softmax-cli
+(including `coworld`, which mounts this subapp as `coworld player`) then acts as that player, because they all
+resolve their token through `softmax.auth.load_current_token`. `softmax player unset` clears the active pointer,
+reverting to your main user credential. `player list`/`use` themselves authenticate with the user token (player
+routes reject player-scoped tokens).
+
+## Tests
+
+```bash
+uv run metta pytest packages/softmax-cli/tests -v
+uv run metta pytest --changed
+```
+
+Tests cover auth/login, the Python API, player identity switching, and CLI plugin wiring; a `BUILD.bazel` exists under
+`tests/`.
+
+## Lint
+
+```bash
+uv run metta lint --fix              # ruff (also runs via the Edit/Write hook)
+```
+
+## Source layout (`src/softmax/`)
+
+- `cli.py` — the Typer app; mounts the `player` subapp via `add_typer`.
+- `auth.py` — token storage, browser login URL, and `whoami` HTTP helpers.
+- `players.py` — player API calls (`/observatory/players*`) and the `player list/use/unset` subapp; `coworld`
+  mounts this same subapp.
+- `perform_login.py` — the local FastAPI/uvicorn callback server used during `softmax login`.
+- `_console.py` — shared rich console helpers.
+
+## Gotchas
+
+- Versioned via `setuptools_scm` off `softmax-v*` git tags (`fallback_version = 0.0.0`).
+- Downstream packages pin an exact `softmax-cli==X.Y.Z`; bumping the public auth API can break them — coordinate version
+  bumps with consumers like `coworld`.
+- `player_sessions[server]` in `credentials.yaml` is a structured object (`active` pointer + per-player `cache` of
+  `{token, expires_at}`), not a flat token string. Use the typed helpers in `auth.py`
+  (`set_active_player_session`, `clear_active_player_session`, `get_active_player_id`, `get_cached_player_session`,
+  `load_player_session`); `load_current_token` returns the active player token when one is selected, else the user
+  token. `softmax player use/unset` drives this.

softmax_cli-0.26.20/CLAUDE.md

@@ -0,0 +1,61 @@
+# AGENTS.md — softmax-cli
+
+The `softmax` CLI: authentication and account tools for Softmax/Observatory. Other packages (e.g. `coworld`) depend on
+it for login/token handling and pin an exact version. Deps: `typer`, `rich`, `httpx`, plus `fastapi`/`uvicorn` for the
+local browser-login callback server. Published to PyPI.
+
+## CLI
+
+Installs a `softmax` entrypoint (`softmax.cli:app`, Typer):
+
+```bash
+uv run softmax login          # browser-based login (spins up a local callback server)
+uv run softmax logout
+uv run softmax status
+uv run softmax get-login-url
+uv run softmax get-token / set-token
+uv run softmax player list / use <player-id> / unset
+```
+
+`softmax player use <player-id>` mints (or reuses) a 24h player session and stores it as the active player in
+`~/.softmax/credentials.yaml` (`player_sessions`). Every auth-backed command in any CLI built on softmax-cli
+(including `coworld`, which mounts this subapp as `coworld player`) then acts as that player, because they all
+resolve their token through `softmax.auth.load_current_token`. `softmax player unset` clears the active pointer,
+reverting to your main user credential. `player list`/`use` themselves authenticate with the user token (player
+routes reject player-scoped tokens).
+
+## Tests
+
+```bash
+uv run metta pytest packages/softmax-cli/tests -v
+uv run metta pytest --changed
+```
+
+Tests cover auth/login, the Python API, player identity switching, and CLI plugin wiring; a `BUILD.bazel` exists under
+`tests/`.
+
+## Lint
+
+```bash
+uv run metta lint --fix              # ruff (also runs via the Edit/Write hook)
+```
+
+## Source layout (`src/softmax/`)
+
+- `cli.py` — the Typer app; mounts the `player` subapp via `add_typer`.
+- `auth.py` — token storage, browser login URL, and `whoami` HTTP helpers.
+- `players.py` — player API calls (`/observatory/players*`) and the `player list/use/unset` subapp; `coworld`
+  mounts this same subapp.
+- `perform_login.py` — the local FastAPI/uvicorn callback server used during `softmax login`.
+- `_console.py` — shared rich console helpers.
+
+## Gotchas
+
+- Versioned via `setuptools_scm` off `softmax-v*` git tags (`fallback_version = 0.0.0`).
+- Downstream packages pin an exact `softmax-cli==X.Y.Z`; bumping the public auth API can break them — coordinate version
+  bumps with consumers like `coworld`.
+- `player_sessions[server]` in `credentials.yaml` is a structured object (`active` pointer + per-player `cache` of
+  `{token, expires_at}`), not a flat token string. Use the typed helpers in `auth.py`
+  (`set_active_player_session`, `clear_active_player_session`, `get_active_player_id`, `get_cached_player_session`,
+  `load_player_session`); `load_current_token` returns the active player token when one is selected, else the user
+  token. `softmax player use/unset` drives this.

{softmax_cli-0.26.18/src/softmax_cli.egg-info → softmax_cli-0.26.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softmax-cli
-Version: 0.26.18
+Version: 0.26.20
 Summary: Softmax CLI — authentication and account tools
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -16,19 +16,18 @@ Requires-Dist: typer>=0.19.2
 Requires-Dist: uvicorn>=0.34.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-httpserver; extra == "test"
 
 # softmax-cli
 
 The `softmax` command-line tool: authentication and account management for Softmax / Observatory. It provides
-browser-based login (with a local callback server), token storage, and account status. Other packages — notably
-`coworld` — depend on it for auth. Installing with the `cogames` extra mounts the cogames CLI as a `softmax cogames`
-subcommand.
+browser-based login (with a local callback server), token storage, account status, and player identity switching.
+Other packages — notably `coworld` — depend on it for auth.
 
 ## Install
 
 ```bash
-uv tool install softmax-cli            # standalone
-uv tool install "softmax-cli[cogames]" # with the cogames subcommand
+uv tool install softmax-cli
 ```
 
 Within the metta workspace it is available via `uv sync`.
@@ -41,7 +40,9 @@ uv run softmax status          # show current auth status
 uv run softmax logout
 uv run softmax get-token       # print the stored token
 uv run softmax set-token       # store a token manually
-uv run softmax cogames ...     # only with the `cogames` extra
+uv run softmax player list     # list your players (active one highlighted)
+uv run softmax player use ply_...  # act as a player in all auth-backed commands
+uv run softmax player unset    # revert to your main user credential
 ```
 
 ## Development

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/README.md

@@ -1,15 +1,13 @@
 # softmax-cli
 
 The `softmax` command-line tool: authentication and account management for Softmax / Observatory. It provides
-browser-based login (with a local callback server), token storage, and account status. Other packages — notably
-`coworld` — depend on it for auth. Installing with the `cogames` extra mounts the cogames CLI as a `softmax cogames`
-subcommand.
+browser-based login (with a local callback server), token storage, account status, and player identity switching.
+Other packages — notably `coworld` — depend on it for auth.
 
 ## Install
 
 ```bash
-uv tool install softmax-cli            # standalone
-uv tool install "softmax-cli[cogames]" # with the cogames subcommand
+uv tool install softmax-cli
 ```
 
 Within the metta workspace it is available via `uv sync`.
@@ -22,7 +20,9 @@ uv run softmax status          # show current auth status
 uv run softmax logout
 uv run softmax get-token       # print the stored token
 uv run softmax set-token       # store a token manually
-uv run softmax cogames ...     # only with the `cogames` extra
+uv run softmax player list     # list your players (active one highlighted)
+uv run softmax player use ply_...  # act as a player in all auth-backed commands
+uv run softmax player unset    # revert to your main user credential
 ```
 
 ## Development

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-test = ["pytest>=8.0"]
+test = ["pytest>=8.0", "pytest-httpserver"]
 
 [project.scripts]
 softmax = "softmax.cli:app"

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/src/softmax/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import importlib
 import sys
 from pkgutil import extend_path
 
@@ -43,10 +42,4 @@ def login(
     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"]
+__all__ = ["login"]

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/src/softmax/auth.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+from datetime import UTC, datetime
 from pathlib import Path
 from urllib.parse import urlencode, urlsplit, urlunsplit
 
@@ -82,7 +83,14 @@ def load_user_token(*, server: str) -> str | None:
 def save_user_token(*, server: str, token: str) -> None:
     server = server.rstrip("/")
     data = _load_data()
-    data.setdefault("tokens", {})[server] = token
+    tokens = data.setdefault("tokens", {})
+    # Player sessions are owned by whoever held the user token. When the user
+    # credential changes (account switch, `login --force`, CI token rotation),
+    # the old player sessions belong to the previous user, so drop them rather
+    # than letting load_current_token keep acting as that stale player.
+    if tokens.get(server) != token:
+        data.get("player_sessions", {}).pop(server, None)
+    tokens[server] = token
     _save_data(data)
 
 
@@ -97,33 +105,91 @@ def _delete_user_token(*, server: str) -> bool:
     return True
 
 
+# --- player sessions ---
+#
+# `player_sessions[server]` holds the active player pointer plus a per-player
+# token cache so `coworld player use <id>` can re-activate a player without
+# re-minting a token until it expires. `load_current_token` returns the active
+# player's token when one is selected, so every auth-backed command transparently
+# acts as that player. Shape:
+#   player_sessions:
+#     <server>:
+#       active: ply_aaa            # currently selected player id, or absent
+#       cache:
+#         ply_aaa: {token: ply_..., expires_at: "2026-..."}
+
+
+class CachedPlayerSession(BaseModel):
+    token: str
+    expires_at: datetime
+
+
+class ServerPlayerSessions(BaseModel):
+    active: str | None = None
+    cache: dict[str, CachedPlayerSession] = Field(default_factory=dict)
+
+
+def _server_sessions(data: dict, server: str) -> ServerPlayerSessions:
+    raw = (data.get("player_sessions") or {}).get(server.rstrip("/")) or {}
+    return ServerPlayerSessions.model_validate(raw)
+
+
+def _store_server_sessions(data: dict, server: str, sessions: ServerPlayerSessions) -> None:
+    data.setdefault("player_sessions", {})[server.rstrip("/")] = sessions.model_dump(mode="json")
+
+
 def load_player_session(*, server: str) -> str | None:
-    server = server.rstrip("/")
-    sessions = _load_data().get("player_sessions", {})
-    token = sessions.get(server)
-    return token if isinstance(token, str) else None
+    """The active player's token, or None when no player is selected or expired.
 
+    Returns None for expired sessions so `load_current_token` falls through to
+    the user token rather than sending a dead player token that produces 401s.
+    """
+    sessions = _server_sessions(_load_data(), server)
+    if sessions.active is None:
+        return None
+    cached = sessions.cache.get(sessions.active)
+    if cached is None:
+        return None
+    if cached.expires_at <= datetime.now(UTC):
+        return None
+    return cached.token
 
-def save_player_session(*, server: str, token: str) -> None:
-    server = server.rstrip("/")
+
+def get_active_player_id(*, server: str) -> str | None:
+    return _server_sessions(_load_data(), server).active
+
+
+def get_cached_player_session(*, server: str, player_id: str) -> CachedPlayerSession | None:
+    return _server_sessions(_load_data(), server).cache.get(player_id)
+
+
+def set_active_player_session(*, server: str, player_id: str, token: str, expires_at: datetime) -> None:
     data = _load_data()
-    data.setdefault("player_sessions", {})[server] = token
+    sessions = _server_sessions(data, server)
+    sessions.cache[player_id] = CachedPlayerSession(token=token, expires_at=expires_at)
+    sessions.active = player_id
+    _store_server_sessions(data, server, sessions)
     _save_data(data)
 
 
-def _delete_player_session(*, server: str) -> bool:
-    server = server.rstrip("/")
+def clear_active_player_session(*, server: str) -> bool:
+    """Clear the active player pointer, reverting to the user token.
+
+    Keeps the cached tokens so a later `use` of the same player can reuse them.
+    Leaves the user token untouched.
+    """
     data = _load_data()
-    sessions = data.get("player_sessions", {})
-    if server not in sessions:
+    sessions = _server_sessions(data, server)
+    if sessions.active is None:
         return False
-    del sessions[server]
+    sessions.active = None
+    _store_server_sessions(data, server, sessions)
     _save_data(data)
     return True
 
 
 def load_current_token(*, server: str) -> str | None:
-    """Returns player_session if present, else user token."""
+    """Returns the active player session token if present, else the user token."""
     return load_player_session(server=server) or load_user_token(server=server)
 
 
@@ -132,8 +198,13 @@ def has_saved_token(*, server: str) -> bool:
 
 
 def delete_all_tokens(*, server: str) -> bool:
+    server = server.rstrip("/")
     deleted_token = _delete_user_token(server=server)
-    deleted_session = _delete_player_session(server=server)
+    data = _load_data()
+    sessions = data.get("player_sessions", {})
+    deleted_session = sessions.pop(server, None) is not None
+    if deleted_session:
+        _save_data(data)
     return deleted_token or deleted_session
 
 

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/src/softmax/cli.py

@@ -20,6 +20,7 @@ from softmax.auth import (
     try_exchange_auth_code,
 )
 from softmax.perform_login import do_interactive_login_for_token
+from softmax.players import player_app
 
 app = typer.Typer(
     help="Softmax CLI — authentication and account tools",
@@ -27,6 +28,7 @@ app = typer.Typer(
     no_args_is_help=True,
     rich_markup_mode="rich",
 )
+app.add_typer(player_app, name="player")
 
 
 def _build_manual_exchange_command(server: str | None = None) -> str:
@@ -167,6 +169,8 @@ def status_cmd(
     ),
 ) -> None:
     """Check authentication status via /whoami."""
+    from softmax.auth import get_active_player_id, load_player_session  # noqa: PLC0415
+
     api_server = server or get_api_server()
     token = load_current_token(server=api_server)
     if not token:
@@ -175,6 +179,15 @@ def status_cmd(
 
     session = fetch_cogames_whoami(api_server=api_server, token=token)
     if session.subject_type == "anonymous":
+        player_token = load_player_session(server=api_server)
+        if player_token and player_token == token:
+            player_id = get_active_player_id(server=api_server)
+            console.print(
+                f"[red]Active player session expired[/red] ({player_id})."
+                " Run [cyan]softmax player use[/cyan] to refresh"
+                " or [cyan]softmax player unset[/cyan] to revert to your user credential."
+            )
+            raise typer.Exit(1)
         console.print("[red]Token is invalid or expired.[/red] Run [cyan]softmax login[/cyan] to re-authenticate.")
         raise typer.Exit(1)
     console.print("[green]Authenticated[/green]")

softmax_cli-0.26.20/src/softmax/players.py

@@ -0,0 +1,138 @@
+"""Player identity management: list players and switch the active player session.
+
+A player is an identity owned by your Softmax user. Activating one stores a 24h
+player session in ~/.softmax/credentials.yaml; `load_current_token` then returns
+the player token, so every auth-backed command in any CLI built on softmax-cli
+(`softmax`, `coworld`, ...) transparently acts as that player.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime, timedelta
+from typing import Annotated
+
+import httpx
+import typer
+from pydantic import BaseModel, ConfigDict
+from rich import box
+from rich.table import Table
+
+from softmax import auth
+from softmax._console import console
+from softmax.auth import DEFAULT_API_SERVER
+
+
+class PlayerResponse(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    id: str  # ply_<uuid>
+    name: str
+    is_default: bool = False
+    avatar_url: str | None = None
+    created_at: datetime
+    disabled_at: datetime | None = None
+    user_id: str | None = None
+
+
+class PlayerLoginResponse(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    player_id: str
+    token: str
+    expires_at: datetime
+
+
+def list_players(*, server: str, token: str) -> list[PlayerResponse]:
+    response = httpx.get(
+        f"{server.rstrip('/')}/observatory/players",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10.0,
+    )
+    response.raise_for_status()
+    return [PlayerResponse.model_validate(entry) for entry in response.json()]
+
+
+def login_player(*, server: str, token: str, player_id: str) -> PlayerLoginResponse:
+    response = httpx.post(
+        f"{server.rstrip('/')}/observatory/players/{player_id}/login",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10.0,
+    )
+    response.raise_for_status()
+    return PlayerLoginResponse.model_validate(response.json())
+
+
+def _user_token(server: str) -> str:
+    # Player routes require a real user identity (USER_AUTH) and reject
+    # player-scoped tokens, so resolve the user token directly rather than
+    # load_current_token, which would pick up the active player session.
+    token = auth.load_user_token(server=server)
+    if token is None:
+        raise RuntimeError(f"Not authenticated. Run: softmax login --server {server}")
+    return token
+
+
+player_app = typer.Typer(no_args_is_help=True, help="Manage the active player identity.")
+
+
+@player_app.command("list")
+def player_list(
+    server: Annotated[str, typer.Option("--server", help="API server URL.")] = DEFAULT_API_SERVER,
+    json_output: Annotated[bool, typer.Option("--json", help="Print raw JSON.")] = False,
+) -> None:
+    active_id = auth.get_active_player_id(server=server)
+    players = list_players(server=server, token=_user_token(server))
+    if json_output:
+        payload = [{**p.model_dump(mode="json"), "active": p.id == active_id} for p in players]
+        print(json.dumps(payload, indent=2))
+        return
+    table = Table(box=box.SIMPLE_HEAVY, show_lines=False, pad_edge=False)
+    table.add_column("")
+    table.add_column("ID")
+    table.add_column("Name")
+    table.add_column("Default")
+    for p in players:
+        is_active = p.id == active_id
+        marker = "[green]●[/green]" if is_active else ""
+        name = f"[bold]{p.name}[/bold]" if is_active else p.name
+        table.add_row(marker, p.id, name, "yes" if p.is_default else "no")
+    console.print(table)
+    if active_id is None:
+        console.print("[dim]No active player; commands act as your main user.[/dim]")
+
+
+@player_app.command("use")
+def player_use(
+    player_id: Annotated[str, typer.Argument(help="Player ID (ply_...) to act as.")],
+    server: Annotated[str, typer.Option("--server", help="API server URL.")] = DEFAULT_API_SERVER,
+) -> None:
+    # Reuse a cached, non-expired session rather than minting a fresh token.
+    cached = auth.get_cached_player_session(server=server, player_id=player_id)
+    if cached is not None and cached.expires_at - timedelta(minutes=5) > datetime.now(UTC):
+        auth.set_active_player_session(
+            server=server, player_id=player_id, token=cached.token, expires_at=cached.expires_at
+        )
+        console.print(f"[green]Active player set to[/green] [bold]{player_id}[/bold] [dim](cached session)[/dim]")
+        return
+
+    token = _user_token(server)
+    players = list_players(server=server, token=token)
+    match = next((p for p in players if p.id == player_id), None)
+    if match is None:
+        console.print(f"[red]Player '{player_id}' not found in your account.[/red]")
+        raise typer.Exit(1)
+    login = login_player(server=server, token=token, player_id=player_id)
+    auth.set_active_player_session(server=server, player_id=player_id, token=login.token, expires_at=login.expires_at)
+    console.print(f"[green]Active player set to[/green] [bold]{match.name}[/bold] ({player_id})")
+    console.print(f"[dim]Session expires:[/dim] {login.expires_at.isoformat()}")
+
+
+@player_app.command("unset")
+def player_unset(
+    server: Annotated[str, typer.Option("--server", help="API server URL.")] = DEFAULT_API_SERVER,
+) -> None:
+    if auth.clear_active_player_session(server=server):
+        console.print("[green]Reverted to your main user credential.[/green]")
+    else:
+        console.print("[yellow]No active player was set.[/yellow]")

{softmax_cli-0.26.18 → softmax_cli-0.26.20/src/softmax_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softmax-cli
-Version: 0.26.18
+Version: 0.26.20
 Summary: Softmax CLI — authentication and account tools
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -16,19 +16,18 @@ Requires-Dist: typer>=0.19.2
 Requires-Dist: uvicorn>=0.34.0
 Provides-Extra: test
 Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-httpserver; extra == "test"
 
 # softmax-cli
 
 The `softmax` command-line tool: authentication and account management for Softmax / Observatory. It provides
-browser-based login (with a local callback server), token storage, and account status. Other packages — notably
-`coworld` — depend on it for auth. Installing with the `cogames` extra mounts the cogames CLI as a `softmax cogames`
-subcommand.
+browser-based login (with a local callback server), token storage, account status, and player identity switching.
+Other packages — notably `coworld` — depend on it for auth.
 
 ## Install
 
 ```bash
-uv tool install softmax-cli            # standalone
-uv tool install "softmax-cli[cogames]" # with the cogames subcommand
+uv tool install softmax-cli
 ```
 
 Within the metta workspace it is available via `uv sync`.
@@ -41,7 +40,9 @@ uv run softmax status          # show current auth status
 uv run softmax logout
 uv run softmax get-token       # print the stored token
 uv run softmax set-token       # store a token manually
-uv run softmax cogames ...     # only with the `cogames` extra
+uv run softmax player list     # list your players (active one highlighted)
+uv run softmax player use ply_...  # act as a player in all auth-backed commands
+uv run softmax player unset    # revert to your main user credential
 ```
 
 ## Development

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/src/softmax_cli.egg-info/SOURCES.txt

@@ -7,8 +7,8 @@ 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/players.py
 src/softmax_cli.egg-info/PKG-INFO
 src/softmax_cli.egg-info/SOURCES.txt
 src/softmax_cli.egg-info/dependency_links.txt
@@ -17,4 +17,5 @@ src/softmax_cli.egg-info/requires.txt
 src/softmax_cli.egg-info/top_level.txt
 tests/BUILD.bazel
 tests/test_auth_login.py
+tests/test_player_cli.py
 tests/test_python_api.py

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/src/softmax_cli.egg-info/requires.txt

@@ -8,3 +8,4 @@ uvicorn>=0.34.0
 
 [test]
 pytest>=8.0
+pytest-httpserver

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/tests/test_auth_login.py

@@ -1,18 +1,28 @@
 from __future__ import annotations
 
 import sys
+from datetime import UTC, datetime, timedelta
 
 import pytest
 from typer.testing import CliRunner
 
 import softmax.perform_login as auth_module
-from softmax.auth import build_browser_login_url, load_user_token, save_player_session, save_user_token
+from softmax.auth import build_browser_login_url, load_user_token, save_user_token, set_active_player_session
 from softmax.cli import _build_manual_exchange_command, app
 from softmax.perform_login import do_interactive_login_for_token
 
 runner = CliRunner()
 
 
+def _activate_player(server: str, token: str, player_id: str = "ply_alpha") -> None:
+    set_active_player_session(
+        server=server,
+        player_id=player_id,
+        token=token,
+        expires_at=datetime.now(UTC) + timedelta(hours=24),
+    )
+
+
 def test_authenticate_exchanges_code_via_callback(
     monkeypatch: pytest.MonkeyPatch,
     tmp_path,
@@ -124,7 +134,7 @@ def test_status_prints_active_subject_details(
     tmp_path,
 ) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
-    save_player_session(server="https://softmax.com/api", token="player-session-token")
+    _activate_player("https://softmax.com/api", "player-session-token")
 
     class FakeResponse:
         def raise_for_status(self) -> None:

softmax_cli-0.26.20/tests/test_player_cli.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime, timedelta
+
+import pytest
+from pytest_httpserver import HTTPServer
+from typer.testing import CliRunner
+
+from softmax.auth import (
+    clear_active_player_session,
+    get_active_player_id,
+    load_current_token,
+    load_player_session,
+    load_user_token,
+    save_user_token,
+    set_active_player_session,
+)
+from softmax.cli import app
+
+PLAYER_ALPHA = {
+    "id": "ply_00000000-0000-0000-0000-0000000000a1",
+    "name": "Alpha",
+    "is_default": True,
+    "avatar_url": None,
+    "created_at": "2026-06-05T12:00:00Z",
+    "disabled_at": None,
+    "user_id": "usr_owner",
+}
+PLAYER_BETA = {
+    "id": "ply_00000000-0000-0000-0000-0000000000b2",
+    "name": "Beta",
+    "is_default": False,
+    "avatar_url": None,
+    "created_at": "2026-06-06T12:00:00Z",
+    "disabled_at": None,
+    "user_id": "usr_owner",
+}
+
+
+@pytest.fixture(autouse=True)
+def _sandbox_credentials(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+    # Isolate ~/.softmax/credentials.yaml under tmp.
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+
+@pytest.fixture
+def _mock_user_auth(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Stub the user token for commands that authenticate against the API. Tests
+    # that assert on real token storage seed it via save_user_token instead.
+    monkeypatch.setattr("softmax.auth.load_user_token", lambda *, server: "user-token")
+
+
+def _activate(server: str, player_id: str, token: str = "ply_session", hours: int = 24) -> None:
+    set_active_player_session(
+        server=server,
+        player_id=player_id,
+        token=token,
+        expires_at=datetime.now(UTC) + timedelta(hours=hours),
+    )
+
+
+def test_list_marks_active(httpserver: HTTPServer, _mock_user_auth: None) -> None:
+    server = httpserver.url_for("")
+    _activate(server, PLAYER_BETA["id"])
+    httpserver.expect_request(
+        "/observatory/players",
+        method="GET",
+        headers={"Authorization": "Bearer user-token"},
+    ).respond_with_json([PLAYER_ALPHA, PLAYER_BETA])
+
+    result = CliRunner().invoke(app, ["player", "list", "--server", server])
+
+    assert result.exit_code == 0, result.output
+    assert "Alpha" in result.output
+    assert "Beta" in result.output
+    # The active marker renders on the Beta row.
+    assert "●" in result.output
+
+
+def test_list_json_includes_active_flag(httpserver: HTTPServer, _mock_user_auth: None) -> None:
+    server = httpserver.url_for("")
+    _activate(server, PLAYER_ALPHA["id"])
+    httpserver.expect_request("/observatory/players", method="GET").respond_with_json([PLAYER_ALPHA, PLAYER_BETA])
+
+    result = CliRunner().invoke(app, ["player", "list", "--server", server, "--json"])
+
+    assert result.exit_code == 0, result.output
+    entries = json.loads(result.output)
+    by_id = {e["id"]: e["active"] for e in entries}
+    assert by_id[PLAYER_ALPHA["id"]] is True
+    assert by_id[PLAYER_BETA["id"]] is False
+
+
+def test_use_mints_and_activates(httpserver: HTTPServer, _mock_user_auth: None) -> None:
+    server = httpserver.url_for("")
+    expires_at = (datetime.now(UTC) + timedelta(hours=24)).isoformat()
+    httpserver.expect_request(
+        "/observatory/players",
+        method="GET",
+        headers={"Authorization": "Bearer user-token"},
+    ).respond_with_json([PLAYER_ALPHA, PLAYER_BETA])
+    httpserver.expect_request(
+        f"/observatory/players/{PLAYER_BETA['id']}/login",
+        method="POST",
+        headers={"Authorization": "Bearer user-token"},
+    ).respond_with_json({"player_id": PLAYER_BETA["id"], "token": "ply_minted", "expires_at": expires_at})
+
+    result = CliRunner().invoke(app, ["player", "use", PLAYER_BETA["id"], "--server", server])
+
+    assert result.exit_code == 0, result.output
+    assert get_active_player_id(server=server) == PLAYER_BETA["id"]
+    assert load_player_session(server=server) == "ply_minted"
+
+
+def test_use_reuses_cached_token_without_network(httpserver: HTTPServer) -> None:
+    server = httpserver.url_for("")
+    # Pre-seed a fresh cached session, then unset so it stays cached but inactive.
+    _activate(server, PLAYER_BETA["id"], token="ply_cached")
+    clear_active_player_session(server=server)
+
+    result = CliRunner().invoke(app, ["player", "use", PLAYER_BETA["id"], "--server", server])
+
+    assert result.exit_code == 0, result.output
+    assert "cached session" in result.output
+    assert get_active_player_id(server=server) == PLAYER_BETA["id"]
+    assert load_player_session(server=server) == "ply_cached"
+    # No HTTP traffic should have hit the server.
+    assert httpserver.log == []
+
+
+def test_use_unknown_id_errors_without_login(httpserver: HTTPServer, _mock_user_auth: None) -> None:
+    server = httpserver.url_for("")
+    httpserver.expect_request("/observatory/players", method="GET").respond_with_json([PLAYER_ALPHA])
+
+    result = CliRunner().invoke(app, ["player", "use", "ply_does_not_exist", "--server", server])
+
+    assert result.exit_code == 1, result.output
+    assert "not found" in result.output
+    # Only the list request was made; no login was attempted.
+    assert all("/login" not in request.path for request, _ in httpserver.log)
+
+
+def test_unset_clears_active_keeps_user_token(httpserver: HTTPServer) -> None:
+    server = httpserver.url_for("")
+    save_user_token(server=server, token="user-token")
+    _activate(server, PLAYER_ALPHA["id"])
+
+    result = CliRunner().invoke(app, ["player", "unset", "--server", server])
+
+    assert result.exit_code == 0, result.output
+    assert "Reverted" in result.output
+    assert load_player_session(server=server) is None
+    assert load_user_token(server=server) == "user-token"
+
+
+def test_unset_when_no_active_player(httpserver: HTTPServer) -> None:
+    server = httpserver.url_for("")
+
+    result = CliRunner().invoke(app, ["player", "unset", "--server", server])
+
+    assert result.exit_code == 0, result.output
+    assert "No active player" in result.output
+
+
+def test_active_player_inherited_by_load_current_token(httpserver: HTTPServer, _mock_user_auth: None) -> None:
+    server = httpserver.url_for("")
+    expires_at = (datetime.now(UTC) + timedelta(hours=24)).isoformat()
+    httpserver.expect_request("/observatory/players", method="GET").respond_with_json([PLAYER_ALPHA])
+    httpserver.expect_request(f"/observatory/players/{PLAYER_ALPHA['id']}/login", method="POST").respond_with_json(
+        {"player_id": PLAYER_ALPHA["id"], "token": "ply_minted", "expires_at": expires_at}
+    )
+
+    result = CliRunner().invoke(app, ["player", "use", PLAYER_ALPHA["id"], "--server", server])
+    assert result.exit_code == 0, result.output
+
+    # Other commands resolve their token via load_current_token, which must now
+    # return the active player token.
+    assert load_current_token(server=server) == "ply_minted"

{softmax_cli-0.26.18 → softmax_cli-0.26.20}/tests/test_python_api.py

@@ -1,14 +1,29 @@
 from __future__ import annotations
 
-import importlib
 import sys
-from typing import Any, cast
+from datetime import UTC, datetime, timedelta
 
 import pytest
 
 import softmax
-import softmax.cogames as softmax_cogames
-from softmax.auth import load_user_token, save_player_session, save_user_token
+from softmax.auth import (
+    clear_active_player_session,
+    get_cached_player_session,
+    load_current_token,
+    load_player_session,
+    load_user_token,
+    save_user_token,
+    set_active_player_session,
+)
+
+
+def _activate_player(server: str, token: str, player_id: str = "ply_alpha") -> None:
+    set_active_player_session(
+        server=server,
+        player_id=player_id,
+        token=token,
+        expires_at=datetime.now(UTC) + timedelta(hours=24),
+    )
 
 
 def test_login_returns_saved_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
@@ -42,7 +57,7 @@ def test_login_runs_interactive_flow_when_missing_token(monkeypatch: pytest.Monk
 def test_login_ignores_player_session_without_saved_user_token(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
     monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
-    save_player_session(server="https://softmax.com/api", token="active-only-token")
+    _activate_player("https://softmax.com/api", "active-only-token")
 
     called = {"interactive": False}
 
@@ -65,88 +80,6 @@ def test_login_requires_tty_when_missing_token(monkeypatch: pytest.MonkeyPatch,
         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) -> None:
-            captured["server_url"] = server_url
-            captured["token"] = token
-
-        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://softmax.com/api",
-        "token": "softmax-token",
-    }
-
-
-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) -> None:
-            self.server_url = server_url
-            self.token = token
-
-        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://softmax.com/api"
-            assert self.token == "softmax-token"
-            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) -> 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_user_token(server="https://softmax.com/api", token="old-token")
@@ -166,7 +99,7 @@ def test_login_returns_user_token_even_with_active_player_session(
     tmp_path,
 ) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
-    save_player_session(server="https://softmax.com/api", token="player-token")
+    _activate_player("https://softmax.com/api", "player-token")
     save_user_token(server="https://softmax.com/api", token="user-token")
 
     called = {"interactive": False}
@@ -178,3 +111,71 @@ def test_login_returns_user_token_even_with_active_player_session(
     assert softmax.login() == "user-token"
     assert load_user_token(server="https://softmax.com/api") == "user-token"
     assert called["interactive"] is False
+
+
+def test_set_and_clear_active_player_session_preserves_user_token(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    server = "https://softmax.com/api"
+    save_user_token(server=server, token="user-token")
+    _activate_player(server, "player-token", player_id="ply_alpha")
+
+    assert load_player_session(server=server) == "player-token"
+
+    assert clear_active_player_session(server=server) is True
+    # Active pointer is gone, so the user token is what's current again.
+    assert load_player_session(server=server) is None
+    assert load_user_token(server=server) == "user-token"
+    # The cached player token survives for a fast re-activation.
+    cached = get_cached_player_session(server=server, player_id="ply_alpha")
+    assert cached is not None
+    assert cached.token == "player-token"
+
+    # Clearing again is a no-op.
+    assert clear_active_player_session(server=server) is False
+
+
+def test_changing_user_token_drops_player_sessions(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    server = "https://softmax.com/api"
+    save_user_token(server=server, token="user-token")
+    _activate_player(server, "player-token", player_id="ply_alpha")
+    assert load_current_token(server=server) == "player-token"
+
+    # Re-saving the same token must NOT disturb the active player session.
+    save_user_token(server=server, token="user-token")
+    assert load_current_token(server=server) == "player-token"
+
+    # Switching the user credential invalidates the old user's player sessions,
+    # so commands act as the new user rather than the stale player.
+    save_user_token(server=server, token="new-user-token")
+    assert load_player_session(server=server) is None
+    assert get_cached_player_session(server=server, player_id="ply_alpha") is None
+    assert load_current_token(server=server) == "new-user-token"
+
+
+def test_expired_player_session_falls_through_to_user_token(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    server = "https://softmax.com/api"
+    save_user_token(server=server, token="user-token")
+
+    # Activate a player with an already-expired session.
+    set_active_player_session(
+        server=server,
+        player_id="ply_alpha",
+        token="expired-player-token",
+        expires_at=datetime.now(UTC) - timedelta(hours=1),
+    )
+
+    # The active pointer is set, but load_player_session skips the expired token.
+    assert load_player_session(server=server) is None
+    # load_current_token falls through to the user token.
+    assert load_current_token(server=server) == "user-token"

softmax_cli-0.26.18/AGENTS.md

@@ -1,48 +0,0 @@
-# AGENTS.md — softmax-cli
-
-The `softmax` CLI: authentication and account tools for Softmax/Observatory. Other packages (e.g. `coworld`) depend on
-it for login/token handling and pin an exact version. Deps: `typer`, `rich`, `httpx`, plus `fastapi`/`uvicorn` for the
-local browser-login callback server. The `cogames` optional extra mounts the cogames CLI as a `softmax cogames`
-subcommand. Published to PyPI.
-
-## CLI
-
-Installs a `softmax` entrypoint (`softmax.cli:app`, Typer):
-
-```bash
-uv run softmax login          # browser-based login (spins up a local callback server)
-uv run softmax logout
-uv run softmax status
-uv run softmax get-login-url
-uv run softmax get-token / set-token
-uv run softmax cogames ...    # only when installed with the `cogames` extra
-```
-
-## Tests
-
-```bash
-uv run metta pytest packages/softmax-cli/tests -v
-uv run metta pytest --changed
-```
-
-Tests cover auth/login, the Python API, and CLI plugin wiring; a `BUILD.bazel` exists under `tests/`.
-
-## Lint
-
-```bash
-uv run metta lint --fix              # ruff (also runs via the Edit/Write hook)
-```
-
-## Source layout (`src/softmax/`)
-
-- `cli.py` — the Typer app; mounts the optional `cogames` subapp via `add_typer`.
-- `auth.py` — token storage, browser login URL, and `whoami` HTTP helpers.
-- `perform_login.py` — the local FastAPI/uvicorn callback server used during `softmax login`.
-- `cogames.py` — the optional cogames subcommand wiring.
-- `_console.py` — shared rich console helpers.
-
-## Gotchas
-
-- Versioned via `setuptools_scm` off `softmax-v*` git tags (`fallback_version = 0.0.0`).
-- Downstream packages pin an exact `softmax-cli==X.Y.Z`; bumping the public auth API can break them — coordinate version
-  bumps with consumers like `coworld`.

softmax_cli-0.26.18/CLAUDE.md

@@ -1,48 +0,0 @@
-# AGENTS.md — softmax-cli
-
-The `softmax` CLI: authentication and account tools for Softmax/Observatory. Other packages (e.g. `coworld`) depend on
-it for login/token handling and pin an exact version. Deps: `typer`, `rich`, `httpx`, plus `fastapi`/`uvicorn` for the
-local browser-login callback server. The `cogames` optional extra mounts the cogames CLI as a `softmax cogames`
-subcommand. Published to PyPI.
-
-## CLI
-
-Installs a `softmax` entrypoint (`softmax.cli:app`, Typer):
-
-```bash
-uv run softmax login          # browser-based login (spins up a local callback server)
-uv run softmax logout
-uv run softmax status
-uv run softmax get-login-url
-uv run softmax get-token / set-token
-uv run softmax cogames ...    # only when installed with the `cogames` extra
-```
-
-## Tests
-
-```bash
-uv run metta pytest packages/softmax-cli/tests -v
-uv run metta pytest --changed
-```
-
-Tests cover auth/login, the Python API, and CLI plugin wiring; a `BUILD.bazel` exists under `tests/`.
-
-## Lint
-
-```bash
-uv run metta lint --fix              # ruff (also runs via the Edit/Write hook)
-```
-
-## Source layout (`src/softmax/`)
-
-- `cli.py` — the Typer app; mounts the optional `cogames` subapp via `add_typer`.
-- `auth.py` — token storage, browser login URL, and `whoami` HTTP helpers.
-- `perform_login.py` — the local FastAPI/uvicorn callback server used during `softmax login`.
-- `cogames.py` — the optional cogames subcommand wiring.
-- `_console.py` — shared rich console helpers.
-
-## Gotchas
-
-- Versioned via `setuptools_scm` off `softmax-v*` git tags (`fallback_version = 0.0.0`).
-- Downstream packages pin an exact `softmax-cli==X.Y.Z`; bumping the public auth API can break them — coordinate version
-  bumps with consumers like `coworld`.

softmax_cli-0.26.18/src/softmax/cogames.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import importlib
-from typing import Any
-
-from softmax.auth import DEFAULT_API_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) -> Any:
-    client_class = _get_tournament_client_class()
-    return client_class(server_url=server, token=token)
-
-
-class _PlayerAPI:
-    def list(
-        self,
-        token: str,
-        *,
-        server: str = DEFAULT_API_SERVER,
-    ) -> list[Any]:
-        with _create_client(token=token, server=server) as client:
-            return client.list_players()
-
-
-player = _PlayerAPI()
-
-
-def login(
-    token: str,
-    player_id: str,
-    *,
-    server: str = DEFAULT_API_SERVER,
-) -> str:
-    with _create_client(token=token, server=server) as client:
-        return client.login_player(player_id).token
-
-
-def login_response(
-    token: str,
-    player_id: str,
-    *,
-    server: str = DEFAULT_API_SERVER,
-) -> Any:
-    with _create_client(token=token, server=server) as client:
-        return client.login_player(player_id)
-
-
-__all__ = ["player", "login", "login_response"]