softmax-cli 0.26.13__tar.gz → 0.26.15__tar.gz

softmax_cli-0.26.15/AGENTS.md

@@ -0,0 +1,48 @@
+# 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.15/BUILD.bazel

@@ -0,0 +1,3 @@
+load("//bazel:pyproject.bzl", "pyproject_library")
+
+pyproject_library(typecheck = False)

softmax_cli-0.26.15/CLAUDE.md

@@ -0,0 +1,48 @@
+# 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.15/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: softmax-cli
+Version: 0.26.15
+Summary: Softmax CLI — authentication and account tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.19.2
+Requires-Dist: uvicorn>=0.34.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; 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.
+
+## Install
+
+```bash
+uv tool install softmax-cli            # standalone
+uv tool install "softmax-cli[cogames]" # with the cogames subcommand
+```
+
+Within the metta workspace it is available via `uv sync`.
+
+## Usage
+
+```bash
+uv run softmax login           # log in via the browser
+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
+```
+
+## Development
+
+```bash
+uv run metta pytest packages/softmax-cli/tests -v   # run tests
+uv run metta lint --fix                              # lint/format
+```
+
+See [AGENTS.md](AGENTS.md) for the source layout and versioning/compatibility notes.

softmax_cli-0.26.15/README.md

@@ -0,0 +1,35 @@
+# 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.
+
+## Install
+
+```bash
+uv tool install softmax-cli            # standalone
+uv tool install "softmax-cli[cogames]" # with the cogames subcommand
+```
+
+Within the metta workspace it is available via `uv sync`.
+
+## Usage
+
+```bash
+uv run softmax login           # log in via the browser
+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
+```
+
+## Development
+
+```bash
+uv run metta pytest packages/softmax-cli/tests -v   # run tests
+uv run metta lint --fix                              # lint/format
+```
+
+See [AGENTS.md](AGENTS.md) for the source layout and versioning/compatibility notes.

{softmax_cli-0.26.13 → softmax_cli-0.26.15}/pyproject.toml

@@ -13,17 +13,18 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-  "typer>=0.19.2",
-  "rich>=13.7.0",
   "fastapi>=0.115.0",
-  "uvicorn>=0.34.0",
   "httpx>=0.28.1",
+  "pydantic>=2.0",
   "pyyaml>=6.0.2",
+  "rich>=13.7.0",
+  "typer>=0.19.2",
+  "uvicorn>=0.34.0",
 ]
 dynamic = ["version"]
 
 [project.optional-dependencies]
-cogames = ["cogames"]
+test = ["pytest>=8.0"]
 
 [project.scripts]
 softmax = "softmax.cli:app"

{softmax_cli-0.26.13 → softmax_cli-0.26.15}/src/softmax/__init__.py

@@ -4,13 +4,8 @@ import importlib
 import sys
 from pkgutil import extend_path
 
-from softmax.auth import (
-    DEFAULT_API_SERVER,
-    load_cogames_user_token,
-    save_cogames_active_token,
-)
+from softmax.auth import DEFAULT_API_SERVER, load_user_token
 from softmax.perform_login import do_interactive_login_for_token
-from softmax.token_storage import TokenKind
 
 __path__ = extend_path(__path__, __name__)
 
@@ -21,9 +16,8 @@ def login(
     force: bool = False,
     open_browser: bool = True,
 ) -> str:
-    token = None if force else load_cogames_user_token(api_server=api_server)
+    token = None if force else load_user_token(server=api_server)
     if token is not None:
-        save_cogames_active_token(api_server=api_server, token=token)
         return token
 
     if not sys.stdin.isatty():
@@ -34,20 +28,18 @@ def login(
 
     do_interactive_login_for_token(
         api_server=api_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"
+            "the auth code. Then paste the code into this window or run:\n"
             "\n"
-            "softmax set-token '<TOKEN>'"
+            "softmax exchange-code '<CODE>'"
         ),
         open_browser=open_browser,
     )
 
-    token = load_cogames_user_token(api_server=api_server)
+    token = load_user_token(server=api_server)
     if token is None:
         raise RuntimeError(f"Interactive login did not save a token for {api_server}")
-    save_cogames_active_token(api_server=api_server, token=token)
     return token
 
 

softmax_cli-0.26.15/src/softmax/auth.py

@@ -0,0 +1,166 @@
+"""Auth helpers for the softmax CLI: token storage, browser login URL, whoami."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from urllib.parse import urlencode, urlsplit, urlunsplit
+
+import httpx
+import yaml
+from pydantic import BaseModel, Field
+
+DEFAULT_API_SERVER = "https://softmax.com/api"
+
+CREDENTIALS_FILE = "credentials.yaml"
+
+
+def get_api_server() -> str:
+    return os.environ.get("COGAMES_API_URL", DEFAULT_API_SERVER)
+
+
+# --- on-disk storage ---
+
+
+def _config_dir() -> Path:
+    config_dir = Path.home() / ".softmax"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def _credentials_path() -> Path:
+    return _config_dir() / CREDENTIALS_FILE
+
+
+def _load_data() -> dict:
+    cred_path = _credentials_path()
+    if not cred_path.exists():
+        return {"tokens": {}, "player_sessions": {}}
+
+    with open(cred_path, "r") as f:
+        return yaml.safe_load(f) or {"tokens": {}, "player_sessions": {}}
+
+
+def _save_data(data: dict) -> None:
+    cred_path = _credentials_path()
+    with open(cred_path, "w") as f:
+        yaml.safe_dump(data, f, default_flow_style=False)
+    os.chmod(cred_path, 0o600)
+
+
+# --- public token API ---
+
+
+def load_user_token(*, server: str) -> str | None:
+    server = server.rstrip("/")
+    tokens = _load_data().get("tokens", {})
+    token = tokens.get(server)
+    return token if isinstance(token, str) else None
+
+
+def save_user_token(*, server: str, token: str) -> None:
+    server = server.rstrip("/")
+    data = _load_data()
+    data.setdefault("tokens", {})[server] = token
+    _save_data(data)
+
+
+def _delete_user_token(*, server: str) -> bool:
+    server = server.rstrip("/")
+    data = _load_data()
+    tokens = data.get("tokens", {})
+    if server not in tokens:
+        return False
+    del tokens[server]
+    _save_data(data)
+    return True
+
+
+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
+
+
+def save_player_session(*, server: str, token: str) -> None:
+    server = server.rstrip("/")
+    data = _load_data()
+    data.setdefault("player_sessions", {})[server] = token
+    _save_data(data)
+
+
+def _delete_player_session(*, server: str) -> bool:
+    server = server.rstrip("/")
+    data = _load_data()
+    sessions = data.get("player_sessions", {})
+    if server not in sessions:
+        return False
+    del sessions[server]
+    _save_data(data)
+    return True
+
+
+def load_current_token(*, server: str) -> str | None:
+    """Returns player_session if present, else user token."""
+    return load_player_session(server=server) or load_user_token(server=server)
+
+
+def has_saved_token(*, server: str) -> bool:
+    return load_current_token(server=server) is not None
+
+
+def delete_all_tokens(*, server: str) -> bool:
+    deleted_token = _delete_user_token(server=server)
+    deleted_session = _delete_player_session(server=server)
+    return deleted_token or deleted_session
+
+
+# --- HTTP / URL helpers ---
+
+
+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(api_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(api_server)
+    # Code-exchange flow lives at /cli-auth; the legacy /cli-login route is
+    # preserved untouched for published softmax-cli <= 0.26.14 (pinned by
+    # coworld[auth]) until those releases age out.
+    browser_path = parsed.path.rstrip("/").removesuffix("/api") + "/cli-auth"
+    return urlunsplit((parsed.scheme, parsed.netloc, browser_path, query, ""))
+
+
+def fetch_cogames_whoami(*, api_server: str | None = None, token: str) -> WhoAmIResponse:
+    server = api_server or DEFAULT_API_SERVER
+    response = httpx.get(
+        f"{server.rstrip('/')}/observatory/whoami",
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=10.0,
+    )
+    response.raise_for_status()
+    return WhoAmIResponse.model_validate(response.json())
+
+
+def exchange_auth_code(*, api_server: str, code: str) -> str:
+    """Exchange a one-time auth code for a real credential token."""
+    response = httpx.post(
+        f"{api_server.rstrip('/')}/observatory/credentials/auth-codes/exchange",
+        json={"code": code},
+        timeout=10.0,
+    )
+    response.raise_for_status()
+    return response.json()["token"]

{softmax_cli-0.26.13 → softmax_cli-0.26.15}/src/softmax/cli.py

@@ -1,7 +1,5 @@
 """softmax CLI — authentication and account tools."""
 
-import importlib
-import importlib.util
 import sys
 
 import httpx
@@ -12,16 +10,15 @@ from softmax._console import console
 from softmax.auth import (
     DEFAULT_API_SERVER,
     build_browser_login_url,
-    delete_cogames_tokens,
+    delete_all_tokens,
+    exchange_auth_code,
     fetch_cogames_whoami,
     get_api_server,
-    load_cogames_user_token,
-    load_current_cogames_token,
-    save_cogames_active_token,
-    save_cogames_user_token,
+    load_current_token,
+    load_user_token,
+    save_user_token,
 )
 from softmax.perform_login import do_interactive_login_for_token
-from softmax.token_storage import TokenKind
 
 app = typer.Typer(
     help="Softmax CLI — authentication and account tools",
@@ -31,20 +28,10 @@ app = typer.Typer(
 )
 
 
-def _register_optional_apps() -> None:
-    if importlib.util.find_spec("cogames") is None:
-        return
-    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(server: str | None = None) -> str:
+def _build_manual_exchange_command(server: str | None = None) -> str:
     if server:
-        return f"softmax set-token --server '{server}' '<TOKEN>'"
-    return "softmax set-token '<TOKEN>'"
+        return f"softmax exchange-code --server '{server}' '<CODE>'"
+    return "softmax exchange-code '<CODE>'"
 
 
 def _print_non_tty_login_instructions(api_server: str | None = None) -> None:
@@ -57,14 +44,14 @@ def _print_non_tty_login_instructions(api_server: str | None = None) -> None:
     console.print()
     console.print("    ", auth_url)
     console.print()
-    console.print("Copy the auth token from the browser, then run:", style="yellow")
+    console.print("Copy the auth code from the browser, then run:", style="yellow")
     console.print()
-    console.print("    ", _build_manual_set_token_command(resolved if is_custom else None))
+    console.print("    ", _build_manual_exchange_command(resolved if is_custom else None))
     console.print()
     console.print(
         Panel(
-            "If you are a coding agent, ask your human to open the URL above and give you the resulting auth token. "
-            "Then run the set-token command above.",
+            "If you are a coding agent, ask your human to open the URL above and give you "
+            "the auth code. Then run the exchange-code command above.",
             title="🤖 Agent Hint",
             border_style="cyan",
         )
@@ -96,7 +83,7 @@ def login_cmd(
     from urllib.parse import urlparse  # noqa: PLC0415
 
     api_server = server or get_api_server()
-    user_token = None if force else load_cogames_user_token(api_server=api_server)
+    user_token = None if force else load_user_token(server=api_server)
     if user_token is not None:
         try:
             whoami = fetch_cogames_whoami(api_server=api_server, token=user_token)
@@ -113,7 +100,6 @@ def login_cmd(
             console.print("Could not reach server to verify token. Proceeding with saved token.", style="yellow")
 
     if user_token is not None:
-        save_cogames_active_token(api_server=api_server, token=user_token)
         console.print(f"Already authenticated with {urlparse(api_server).hostname}", style="green")
         return
 
@@ -124,12 +110,11 @@ def login_cmd(
     try:
         do_interactive_login_for_token(
             api_server=api_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"
+                "the auth code. Then paste the code into this window or run:\n"
                 "\n"
-                f"{_build_manual_set_token_command(server)}"
+                f"{_build_manual_exchange_command(server)}"
             ),
             open_browser=not no_browser,
         )
@@ -139,9 +124,6 @@ def login_cmd(
         console.print("Authentication failed.", style="red")
         raise typer.Exit(1) from e
 
-    user_token = load_cogames_user_token(api_server=api_server)
-    assert user_token is not None
-    save_cogames_active_token(api_server=api_server, token=user_token)
     console.print("Authentication successful.", style="green")
 
 
@@ -157,7 +139,7 @@ def logout_cmd(
 ) -> None:
     """Remove saved authentication token."""
     api_server = server or get_api_server()
-    if delete_cogames_tokens(api_server=api_server):
+    if delete_all_tokens(server=api_server):
         console.print("Logged out.", style="green")
     else:
         console.print("No token found — already logged out.", style="yellow")
@@ -189,7 +171,7 @@ def status_cmd(
 ) -> None:
     """Check authentication status via /whoami."""
     api_server = server or get_api_server()
-    token = load_current_cogames_token(api_server=api_server)
+    token = load_current_token(server=api_server)
     if not token:
         console.print("[red]Not authenticated.[/red] Run [cyan]softmax login[/cyan] first.")
         raise typer.Exit(1)
@@ -217,7 +199,7 @@ def get_token_cmd(
 ) -> None:
     """Print the saved token to stdout (for scripting)."""
     api_server = server or get_api_server()
-    token = load_current_cogames_token(api_server=api_server)
+    token = load_current_token(server=api_server)
     if not token:
         console.print("[red]No token found.[/red] Run [cyan]softmax login[/cyan] first.", style="bold")
         raise typer.Exit(1)
@@ -237,8 +219,23 @@ def set_token_cmd(
 ) -> None:
     """Manually set a token (for CI or headless environments)."""
     api_server = server or get_api_server()
-    save_cogames_user_token(api_server=api_server, token=token)
+    save_user_token(server=api_server, token=token)
     print(f"\nToken saved for {api_server}")
 
 
-_register_optional_apps()
+@app.command(name="exchange-code")
+def exchange_code_cmd(
+    code: str = typer.Argument(help="One-time auth code from browser login"),
+    server: str | None = typer.Option(
+        None,
+        "--server",
+        "-s",
+        metavar="URL",
+        help="API server URL.",
+    ),
+) -> None:
+    """Exchange a one-time auth code for a credential."""
+    api_server = server or get_api_server()
+    token = exchange_auth_code(api_server=api_server, code=code)
+    save_user_token(server=api_server, token=token)
+    print(f"\nToken saved for {api_server}")