opensees-cli 0.2.2__tar.gz → 0.2.4__tar.gz

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: Run OpenSees simulations in the cloud from the command line.
 Author: Minjie Zhu
 License: Proprietary

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensees_cli"
-version = "0.2.2"
+version = "0.2.4"
 description = "Run OpenSees simulations in the cloud from the command line."
 readme = "README.md"
 requires-python = ">=3.9"

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/__init__.py

@@ -1,3 +1,3 @@
 """OpenSees CLI — run structural simulations in the cloud."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/admin.py

@@ -2,7 +2,8 @@
 
 import json
 import re
-from typing import Any, Optional
+from pathlib import Path
+from typing import Any, List, Optional
 
 import click
 import typer
@@ -10,12 +11,29 @@ from rich.console import Console
 from rich.table import Table
 from typer.core import TyperGroup
 
-from opensees_cli import api, config
-from opensees_cli.auth import _to_local, _fmt_bytes, print_quota
+from opensees_cli import __version__, api, config
+from opensees_cli.auth import _to_local, print_quota
+from opensees_cli.files import download as files_download
+from opensees_cli.files import list_files as files_list
+from opensees_cli.run import _BareDefaultCommand
+from opensees_cli.run import data as run_data
+from opensees_cli.run import list_analyses as run_list
+from opensees_cli.run import output as run_output
+from opensees_cli.run import stats as run_stats
+from opensees_cli.run import status as run_status
 
 _RUNTIME_TOKEN_RE = re.compile(r"^((\d+(?:\.\d+)?)(h|m|s))+$")
 
 
+def _cli_cell(raw: Optional[str], current: str) -> str:
+    v = (raw or "").strip()
+    if not v:
+        return "-"
+    if config.is_older_version(v, current):
+        return f"[yellow]{v}[/yellow]"
+    return v
+
+
 def _parse_runtime_quota(raw: str) -> int:
     """Parse -r: plain digits = seconds; or duration tokens like 2h, 10m, 1h30m, 90s."""
     s = raw.strip().lower().replace(" ", "")
@@ -106,14 +124,17 @@ def list_users():
         console.print("[dim]No users found.[/dim]")
         return
 
-    table = Table(title=f"Users ({len(users)})")
-    table.add_column("Email", style="cyan")
+    current_cli = __version__
+    table = Table(title=f"Users ({len(users)}) · current CLI {current_cli}")
+    # Always show the full email (never ellipsize / crop).
+    table.add_column("Email", style="cyan", overflow="ignore", no_wrap=True)
     table.add_column("Status")
     table.add_column("Enabled")
     table.add_column("Admin")
     table.add_column("Last Login")
     table.add_column("Last Activity")
-    table.add_column("Pinned")
+    table.add_column("CLI", overflow="ignore", no_wrap=True)
+    table.add_column("Pinned", overflow="ignore", no_wrap=True)
 
     for u in users:
         enabled = "[green]yes[/green]" if u.get("enabled") else "[red]no[/red]"
@@ -125,6 +146,7 @@ def list_users():
             admin,
             u.get("last_login_at", "") or "-",
             u.get("last_activity_at", "") or "-",
+            _cli_cell(u.get("last_cli_version"), current_cli),
             u.get("openseespy_version", "") or "-",
         )
     console.print(table)
@@ -175,11 +197,7 @@ def delete_user(email: Optional[str] = typer.Option(None, "--email", "-e")):
         raise typer.Exit(1)
 
 
-@app.command("user-info")
-def user_info(email: Optional[str] = typer.Option(None, "--email", "-e")):
-    """Show a user's account details, quota, analyses, and files."""
-    if not email:
-        email = typer.prompt("Email")
+def _print_user_info(email: str) -> None:
     try:
         r = api.post("/admin/user-info", {"email": email})
     except api.ApiError as e:
@@ -200,8 +218,14 @@ def user_info(email: Optional[str] = typer.Option(None, "--email", "-e")):
         console.print(f"  OpenSeesPy:   {pin} (pinned)")
     else:
         console.print("  OpenSeesPy:   [dim]-[/dim] (not pinned)")
-    if r.get("last_cli_version"):
-        console.print(f"  CLI version:  {r['last_cli_version']}")
+    cli_ver = (r.get("last_cli_version") or "").strip()
+    if cli_ver:
+        if config.is_older_version(cli_ver, __version__):
+            console.print(f"  CLI:          [yellow]{cli_ver}[/yellow]  (behind {__version__})")
+        else:
+            console.print(f"  CLI:          {cli_ver}")
+    else:
+        console.print("  CLI:          [dim]-[/dim]")
     if r.get("last_ip"):
         console.print(f"  Last IP:      {r['last_ip']}")
 
@@ -210,62 +234,6 @@ def user_info(email: Optional[str] = typer.Option(None, "--email", "-e")):
         console.print()
         print_quota(q)
 
-    analyses = r.get("analyses") or []
-    analyses_total = int(r.get("analyses_total") or 0)
-    analyses_running = int(r.get("analyses_running") or 0)
-    console.print()
-    extra = f", {analyses_running} running" if analyses_running else ""
-    console.print(f"[bold]Analyses[/bold]  [dim]{analyses_total} total{extra}[/dim]")
-    if not analyses:
-        console.print("  [dim]No analyses.[/dim]")
-    else:
-        table = Table(show_header=True)
-        table.add_column("Analysis", style="dim", max_width=8)
-        table.add_column("Status")
-        table.add_column("Type")
-        table.add_column("File")
-        table.add_column("Tasks")
-        table.add_column("Created")
-        for a in analyses:
-            aid = (a.get("analysis_id") or "")[:8]
-            total = int(a.get("total_tasks") or 1)
-            table.add_row(
-                aid,
-                str(a.get("status") or ""),
-                str(a.get("type") or ""),
-                str(a.get("filename") or ""),
-                str(total),
-                _to_local(a["created_at"]) if a.get("created_at") else "",
-            )
-        console.print(table)
-        if analyses_total > len(analyses):
-            console.print(f"  [dim]Showing {len(analyses)} of {analyses_total}.[/dim]")
-
-    files = r.get("files") or []
-    files_total = int(r.get("files_total") or 0)
-    files_size = int(r.get("files_size") or 0)
-    console.print()
-    console.print(
-        f"[bold]Files[/bold]  [dim]{files_total} file"
-        f"{'' if files_total == 1 else 's'}, {_fmt_bytes(files_size)}[/dim]"
-    )
-    if not files:
-        console.print("  [dim]No files.[/dim]")
-    else:
-        table = Table(show_header=True)
-        table.add_column("Path")
-        table.add_column("Size", justify="right")
-        table.add_column("Modified")
-        for f in files:
-            table.add_row(
-                str(f.get("path") or ""),
-                _fmt_bytes(f.get("size") or 0),
-                _to_local(f["last_modified"]) if f.get("last_modified") else "",
-            )
-        console.print(table)
-        if files_total > len(files):
-            console.print(f"  [dim]Showing {len(files)} of {files_total}.[/dim]")
-
 
 @app.command("set-quota")
 def set_quota(
@@ -415,3 +383,205 @@ def workers(
             _to_local(t["started_at"]) if t.get("started_at") else "-",
         )
     console.print(table)
+
+
+# ---------------------------------------------------------------------------
+# user-info: account details, plus read-only run / files inspect
+# ---------------------------------------------------------------------------
+
+user_info_grp = typer.Typer(help="Show a user's account details; run / files inspect that user.")
+run_grp = typer.Typer(help="Inspect the user's analyses (read-only).")
+files_grp = typer.Typer(help="Inspect the user's files (read-only).")
+
+
+def _email_from_ctx(ctx: typer.Context) -> Optional[str]:
+    cur: Optional[click.Context] = ctx
+    while cur is not None:
+        obj = cur.obj
+        if isinstance(obj, dict) and obj.get("email"):
+            return str(obj["email"])
+        cur = cur.parent
+    return None
+
+
+def _resolve_email(ctx: typer.Context, email: Optional[str]) -> str:
+    resolved = (email or _email_from_ctx(ctx) or "").strip()
+    if not resolved:
+        console.print("[red]Provide --email / -e for the target user.[/red]")
+        raise typer.Exit(1)
+    return resolved
+
+
+def _email_opt() -> Any:
+    return typer.Option(None, "--email", "-e", help="Target user's email")
+
+
+@user_info_grp.callback(invoke_without_command=True)
+def user_info(
+    ctx: typer.Context,
+    email: Optional[str] = typer.Option(None, "--email", "-e", help="Target user's email"),
+):
+    """Show a user's account details and quota."""
+    ctx.ensure_object(dict)
+    if email:
+        ctx.obj["email"] = email.strip()
+    if ctx.invoked_subcommand is not None:
+        return
+    if not email:
+        email = typer.prompt("Email")
+        ctx.obj["email"] = email.strip()
+    _print_user_info(email)
+
+
+@run_grp.callback(invoke_without_command=True)
+def _admin_run_callback(ctx: typer.Context) -> None:
+    ctx.ensure_object(dict)
+    parent_email = _email_from_ctx(ctx)
+    if parent_email:
+        ctx.obj["email"] = parent_email
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@files_grp.callback(invoke_without_command=True)
+def _admin_files_callback(ctx: typer.Context) -> None:
+    ctx.ensure_object(dict)
+    parent_email = _email_from_ctx(ctx)
+    if parent_email:
+        ctx.obj["email"] = parent_email
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@run_grp.command("list", cls=_BareDefaultCommand)
+def admin_run_list(
+    ctx: typer.Context,
+    email: Optional[str] = _email_opt(),
+    limit: int = typer.Option(20, "--limit", "-n", help="Max number of analyses to show"),
+    after: Optional[str] = typer.Option(None, "--after", help="Show analyses after date (YYYY-MM-DD)"),
+    before: Optional[str] = typer.Option(None, "--before", help="Show analyses before date (YYYY-MM-DD)"),
+    week: Optional[str] = typer.Option(
+        None, "--week", "-w",
+        help="Week filter: 0=this week; 1-52=ISO week; negative=-k; W1-W2=range.",
+    ),
+    month: Optional[str] = typer.Option(
+        None, "--month", "-m",
+        help="Month filter: 0=this month; 1-12; negative=-k; M-N=range.",
+    ),
+    year: Optional[str] = typer.Option(
+        None, "--year", "-y",
+        help="Year filter: 0=this year; positive=absolute year; negative=-k; Y1-Y2=range.",
+    ),
+    all_: bool = typer.Option(False, "--all", "-a", help="Show all analyses (no date filter)"),
+    as_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """List the user's analyses.
+
+    Same flags as ``ops run list``. Example: ops admin user-info run list -e alice@test.com
+    """
+    with api.acting_as(_resolve_email(ctx, email)):
+        run_list(
+            limit=limit,
+            after=after,
+            before=before,
+            week=week,
+            month=month,
+            year=year,
+            all_=all_,
+            as_json=as_json,
+        )
+
+
+@run_grp.command("status")
+def admin_run_status(
+    ctx: typer.Context,
+    id: Optional[str] = typer.Argument(None, help="Analysis ID (omit to list running analyses)"),
+    range_: Optional[str] = typer.Argument(None, help="Task range: index, start-end, or 'all'"),
+    email: Optional[str] = _email_opt(),
+    as_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Show the user's analysis or task status."""
+    with api.acting_as(_resolve_email(ctx, email)):
+        run_status(id=id, range_=range_, as_json=as_json)
+
+
+@run_grp.command("output")
+def admin_run_output(
+    ctx: typer.Context,
+    id: str = typer.Argument(..., help="Analysis ID"),
+    range_: Optional[str] = typer.Argument(None, help="Task range: index, start-end, or 'all'"),
+    email: Optional[str] = _email_opt(),
+):
+    """Show the user's printed output (stdout)."""
+    with api.acting_as(_resolve_email(ctx, email)):
+        run_output(id=id, range_=range_)
+
+
+@run_grp.command("stats")
+def admin_run_stats(
+    ctx: typer.Context,
+    id: str = typer.Argument(..., help="Analysis ID"),
+    range_: Optional[str] = typer.Argument(None, help="Task range: index, start-end, or 'all'"),
+    email: Optional[str] = _email_opt(),
+):
+    """Show the user's task execution stats."""
+    with api.acting_as(_resolve_email(ctx, email)):
+        run_stats(id=id, range_=range_)
+
+
+@run_grp.command("data")
+def admin_run_data(
+    ctx: typer.Context,
+    id: str = typer.Argument(..., help="Analysis ID"),
+    range_: Optional[str] = typer.Argument(None, help="Task range: index, start-end, or 'all'"),
+    email: Optional[str] = _email_opt(),
+    download: Optional[str] = typer.Option(
+        None, "--download", "-d", metavar="PATH",
+        help="Download mode (omit to list only). Same as ``ops run data -d``.",
+    ),
+    output_dir: str = typer.Option(
+        ".", "--output", "-o",
+        help="Directory to write downloaded files.",
+    ),
+):
+    """List or download the user's task data files."""
+    with api.acting_as(_resolve_email(ctx, email)):
+        run_data(id=id, range_=range_, download=download, output_dir=output_dir)
+
+
+@files_grp.command("list")
+def admin_files_list(
+    ctx: typer.Context,
+    folder: Optional[str] = typer.Argument(
+        None,
+        help="Only list files in this folder (and its subfolders)",
+    ),
+    email: Optional[str] = _email_opt(),
+    as_json: bool = typer.Option(False, "--json", "-j", help="Emit JSON instead of a table"),
+):
+    """List the user's files."""
+    email = _resolve_email(ctx, email)
+    console.print(f"[dim]Files for {email}[/dim]")
+    with api.acting_as(email):
+        files_list(folder=folder, as_json=as_json)
+
+
+@files_grp.command("download")
+def admin_files_download(
+    ctx: typer.Context,
+    remote_paths: List[str] = typer.Argument(..., help="Remote file path(s) or glob pattern(s)"),
+    email: Optional[str] = _email_opt(),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Local output path"),
+):
+    """Download file(s) from the user's file system."""
+    with api.acting_as(_resolve_email(ctx, email)):
+        files_download(remote_paths=remote_paths, output=output)
+
+
+user_info_grp.add_typer(run_grp, name="run")
+user_info_grp.add_typer(files_grp, name="files")
+app.add_typer(user_info_grp, name="user-info")
+
+

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/api.py

@@ -4,7 +4,9 @@ Handles auth headers and automatic token refresh when the server reports an
 expired session (HTTP 401, or HTTP 400 with code ``auth_error`` — e.g. /auth/me).
 """
 
-from typing import Any, Dict, Optional
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Iterator, Optional
 
 import httpx
 
@@ -22,6 +24,7 @@ TIMEOUT = 30.0
 # Seconds before access-token expiry to refresh proactively (when expires_at is known).
 _REFRESH_BUFFER_SEC = 300
 _session_ok: Optional[bool] = None
+_as_user: ContextVar[Optional[str]] = ContextVar("as_user", default=None)
 
 
 class ApiError(Exception):
@@ -32,6 +35,25 @@ class ApiError(Exception):
         super().__init__(message)
 
 
+@contextmanager
+def acting_as(email: str) -> Iterator[None]:
+    """Send ``as_user=<email>`` on subsequent GET requests (admin impersonation)."""
+    token = _as_user.set((email or "").strip().lower() or None)
+    try:
+        yield
+    finally:
+        _as_user.reset(token)
+
+
+def _merge_as_user(params: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    email = _as_user.get()
+    if not email:
+        return params
+    merged = dict(params or {})
+    merged["as_user"] = email
+    return merged
+
+
 def invalidate_session_cache() -> None:
     global _session_ok
     _session_ok = None
@@ -164,6 +186,9 @@ def _headers(token: Optional[str] = None) -> Dict[str, str]:
         h["Authorization"] = f"Bearer {id_tok}"
     if access_tok:
         h["X-Access-Token"] = access_tok
+    as_user = _as_user.get()
+    if as_user:
+        h["X-As-User"] = as_user
     return h
 
 
@@ -288,13 +313,21 @@ def post(path: str, body: Dict[str, Any], auth: bool = True) -> Dict[str, Any]:
 
 def get(path: str, params: Optional[Dict[str, Any]] = None, auth: bool = True) -> Dict[str, Any]:
     hdrs = _headers() if auth else _headers(token="")
+    params = _merge_as_user(params)
     resp = httpx.get(_url(path), params=params, headers=hdrs, timeout=TIMEOUT)
     if auth and _needs_auth_refresh(resp):
         if _try_refresh():
             resp = httpx.get(_url(path), params=params, headers=_headers(), timeout=TIMEOUT)
         else:
             _auth_failure()
-    return _parse(resp)
+    data = _parse(resp)
+    expected = _as_user.get()
+    if expected and str(data.get("as_user") or "").strip().lower() != expected:
+        raise ApiError(
+            "Server did not switch to the target user. Deploy the API (./deploy-api.sh) and try again.",
+            status=resp.status_code,
+        )
+    return data
 
 
 def upload_file(presigned_url: str, file_bytes: bytes, content_type: str = "text/x-python") -> None:

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/auth.py

@@ -2,15 +2,65 @@
 
 import json
 import sys
+import time
 from typing import Any, Dict, Optional, Sequence
 
+import httpx
 import typer
 from rich.console import Console
 
-from opensees_cli import api, config
+from opensees_cli import __version__, api, config
 
 console = Console()
 
+_PYPI_CLI_URL = "https://pypi.org/pypi/opensees_cli/json"
+_PYPI_CACHE_TTL_SEC = 24 * 3600
+
+
+def maybe_print_cli_upgrade(*, latest: Optional[str] = None) -> None:
+    """If a newer opensees_cli is on PyPI, print a one-line pip upgrade hint."""
+    newest = (latest or _pypi_latest_cli_version() or "").strip()
+    if not newest or not config.is_older_version(__version__, newest):
+        return
+    console.print(
+        f"[yellow]A newer opensees_cli is available ({newest}; you have {__version__}).[/yellow]"
+    )
+    console.print("[yellow]Upgrade: pip install -U opensees_cli[/yellow]")
+
+
+def _pypi_latest_cli_version() -> Optional[str]:
+    """Latest PyPI version, cached ~24h. Best-effort; never raises."""
+    if "pytest" in sys.modules:
+        return None
+    cache_path = config.CONFIG_DIR / "pypi_cli_latest.json"
+    now = time.time()
+    try:
+        cached = json.loads(cache_path.read_text(encoding="utf-8"))
+        ver = str(cached.get("version") or "").strip()
+        checked = float(cached.get("checked_at") or 0)
+        if ver and now - checked < _PYPI_CACHE_TTL_SEC:
+            return ver
+    except (OSError, TypeError, ValueError, json.JSONDecodeError):
+        pass
+    try:
+        r = httpx.get(_PYPI_CLI_URL, timeout=2.0)
+        if r.status_code != 200:
+            return None
+        ver = str((r.json().get("info") or {}).get("version") or "").strip()
+    except Exception:
+        return None
+    if not ver:
+        return None
+    try:
+        config._ensure_dir()
+        cache_path.write_text(
+            json.dumps({"version": ver, "checked_at": now}),
+            encoding="utf-8",
+        )
+    except OSError:
+        pass
+    return ver
+
 _CONFIRM_CLI_HINT = (
     "[dim]Use [bold]ops auth confirm[/bold] to confirm the verification code.[/dim]"
 )
@@ -457,7 +507,6 @@ def login(email: Optional[str] = typer.Option(None, "--email", "-e")):
     password = _ask_password()
 
     try:
-        from opensees_cli import __version__
         r = api.post(
             "/auth/login",
             {
@@ -478,6 +527,7 @@ def login(email: Optional[str] = typer.Option(None, "--email", "-e")):
         )
         api.invalidate_session_cache()
         console.print(f"[green]Logged in as [bold]{email}[/bold][/green]")
+        maybe_print_cli_upgrade()
     except api.ApiError as e:
         console.print(f"[red]{e.message}[/red]")
         raise typer.Exit(1)

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/config.py

@@ -14,7 +14,7 @@ import re
 import sys
 import time
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 CONFIG_DIR = Path.home() / ".opensees"
 CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
@@ -168,26 +168,50 @@ def get_api_url() -> str:
 # OpenSeesPy version (sticky local preference)
 # ---------------------------------------------------------------------------
 
-OPENSEESPY_VERSION_FILE = CONFIG_DIR / "openseespy_version"
+def _openseespy_version_file() -> Path:
+    return CONFIG_DIR / "openseespy_version"
 
 
 def set_openseespy_version(version: str) -> None:
     """Save the sticky OpenSeesPy version preference."""
     _ensure_dir()
-    OPENSEESPY_VERSION_FILE.write_text(version.strip())
+    _openseespy_version_file().write_text(version.strip())
 
 
 def get_openseespy_version() -> Optional[str]:
     """Return the sticky OpenSeesPy version, or None if not set."""
-    if not OPENSEESPY_VERSION_FILE.exists():
+    path = _openseespy_version_file()
+    if not path.exists():
         return None
     try:
-        return OPENSEESPY_VERSION_FILE.read_text().strip() or None
+        return path.read_text().strip() or None
     except OSError:
         return None
 
 
 def clear_openseespy_version() -> None:
     """Clear the sticky OpenSeesPy version preference."""
-    if OPENSEESPY_VERSION_FILE.exists():
-        OPENSEESPY_VERSION_FILE.unlink()
+    path = _openseespy_version_file()
+    if path.exists():
+        path.unlink()
+
+
+def version_tuple(raw: str) -> Tuple[int, ...]:
+    """Numeric dotted version parts, or empty if none (e.g. ``web/1.0.0`` still parses)."""
+    parts: list[int] = []
+    for token in re.findall(r"\d+", (raw or "").strip()):
+        parts.append(int(token))
+        if len(parts) >= 4:
+            break
+    return tuple(parts)
+
+
+def is_older_version(installed: str, latest: str) -> bool:
+    """True when *installed* is a lower dotted version than *latest*."""
+    a, b = version_tuple(installed), version_tuple(latest)
+    if not a or not b:
+        return False
+    n = max(len(a), len(b))
+    a = a + (0,) * (n - len(a))
+    b = b + (0,) * (n - len(b))
+    return a < b

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli/main.py

@@ -8,6 +8,7 @@ from opensees_cli import __version__
 from opensees_cli.auth import (
     app as auth_app,
     format_status_json,
+    maybe_print_cli_upgrade,
     print_me,
     print_quota,
 )
@@ -140,7 +141,7 @@ def _print_help() -> None:
             console.print()
             console.print("[bold]ops admin[/bold]\n")
             console.print("  [bold]list-users[/bold]        List all users")
-            console.print("  [bold]user-info[/bold]         Show a user's details")
+            console.print("  [bold]user-info[/bold]         Account details; run / files inspect that user")
             console.print("  [bold]set-quota[/bold]         Update a user's quota")
             console.print("  [bold]enable-user[/bold]       Re-enable a user")
             console.print("  [bold]disable-user[/bold]      Disable a user")
@@ -161,6 +162,7 @@ def _print_help() -> None:
 
     console.print()
     console.print("[dim]Run any command with --help for more details.[/dim]")
+    maybe_print_cli_upgrade()
 
 
 @app.callback(invoke_without_command=True)
@@ -221,7 +223,9 @@ def status(
     q = r.get("quota")
     if not q:
         console.print("[dim]No quota info available.[/dim]")
+        maybe_print_cli_upgrade()
         return
     console.print()
     print_quota(q)
+    maybe_print_cli_upgrade()
 

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/src/opensees_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: Run OpenSees simulations in the cloud from the command line.
 Author: Minjie Zhu
 License: Proprietary

opensees_cli-0.2.4/tests/test_admin_commands.py

@@ -0,0 +1,296 @@
+"""Tests for ops admin subcommands — one test per command, using admin creds."""
+
+from unittest.mock import patch
+
+from opensees_cli.main import app
+
+
+class TestListUsers:
+    def test_list_users(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/admin/users", json={
+            "users": [
+                {
+                    "email": "alice@test.com",
+                    "status": "CONFIRMED",
+                    "enabled": True,
+                    "is_admin": False,
+                    "last_login_at": "2025-01-01T00:00:00Z",
+                    "last_activity_at": "",
+                    "last_cli_version": "0.2.1",
+                    "openseespy_version": "3.7.1.0",
+                },
+            ]
+        })
+        result = cli_runner.invoke(app, ["admin", "list-users"])
+        assert result.exit_code == 0
+        assert "alice@test.com" in result.output
+        assert "3.7.1.0" in result.output
+        assert "0.2.1" in result.output
+        assert "CLI" in result.output
+        assert "Pinned" in result.output
+        from opensees_cli import __version__
+        assert f"current CLI {__version__}" in result.output
+
+    def test_list_users_empty(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/admin/users", json={"users": []})
+        result = cli_runner.invoke(app, ["admin", "list-users"])
+        assert result.exit_code == 0
+        assert "No users" in result.output
+
+
+class TestDisableUser:
+    def test_disable_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/disable-user", json={"message": "User disabled."})
+        result = cli_runner.invoke(app, ["admin", "disable-user", "-e", "alice@test.com"])
+        assert result.exit_code == 0
+        assert "disabled" in result.output.lower()
+
+
+class TestEnableUser:
+    def test_enable_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/enable-user", json={"message": "User enabled."})
+        result = cli_runner.invoke(app, ["admin", "enable-user", "-e", "alice@test.com"])
+        assert result.exit_code == 0
+        assert "enabled" in result.output.lower()
+
+
+class TestDeleteUser:
+    def test_delete_user_confirmed(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/delete-user", json={"message": "User deleted."})
+        result = cli_runner.invoke(app, ["admin", "delete-user", "-e", "alice@test.com"], input="y\n")
+        assert result.exit_code == 0
+        assert "deleted" in result.output.lower()
+
+    def test_delete_user_cancelled(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "delete-user", "-e", "alice@test.com"], input="n\n")
+        assert result.exit_code == 0
+        assert "Cancelled" in result.output
+
+
+class TestUserInfo:
+    def test_user_info(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/user-info", json={
+            "email": "alice@test.com",
+            "is_admin": False,
+            "is_enabled": True,
+            "openseespy_version": "3.7.1.0",
+            "last_cli_version": "0.2.2",
+            "quota": {
+                "max_concurrent_runs": 5,
+                "max_tasks_per_analysis": 100,
+                "max_monthly_runtime": 3600,
+                "monthly_runtime_used": 0,
+                "monthly_runtime_remaining": 3600,
+                "max_monthly_storage": 1073741824,
+                "storage_used": 0,
+            },
+            "analyses_total": 2,
+            "analyses_running": 1,
+            "analyses": [
+                {
+                    "analysis_id": "aaa11111-0000-0000-0000-000000000000",
+                    "status": "running",
+                    "filename": "Truss.py",
+                    "type": "fast",
+                    "total_tasks": 1,
+                    "created_at": "2026-09-01T00:00:00Z",
+                },
+            ],
+            "files_total": 1,
+            "files_size": 128,
+            "files": [
+                {"path": "Truss.py", "size": 128, "last_modified": "2026-09-01T00:00:00Z"},
+            ],
+        })
+        result = cli_runner.invoke(app, ["admin", "user-info", "-e", "alice@test.com"])
+        assert result.exit_code == 0
+        assert "alice@test.com" in result.output
+        assert "3.7.1.0" in result.output
+        assert "pinned" in result.output.lower()
+        assert "0.2.2" in result.output
+        assert "CLI" in result.output
+        assert "Analyses" not in result.output
+        assert "Files" not in result.output
+
+    def test_user_info_not_pinned(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/user-info", json={
+            "email": "bob@test.com",
+            "is_admin": False,
+            "is_enabled": True,
+            "openseespy_version": None,
+        })
+        result = cli_runner.invoke(app, ["admin", "user-info", "-e", "bob@test.com"])
+        assert result.exit_code == 0
+        assert "not pinned" in result.output.lower()
+        assert "No analyses" not in result.output
+        assert "No files" not in result.output
+
+
+class TestSetQuota:
+    def test_set_quota_runtime(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/set-quota", json={"message": "Quota updated."})
+        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "alice@test.com", "-r", "2h"])
+        assert result.exit_code == 0
+        assert "updated" in result.output.lower()
+
+    def test_set_quota_no_flags(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "alice@test.com"])
+        assert result.exit_code == 0
+        assert "Provide at least one" in result.output
+
+    def test_set_quota_invalid_runtime(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "a@t.com", "-r", "abc"])
+        assert result.exit_code == 1
+        assert "Invalid" in result.output
+
+    def test_set_quota_storage(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/admin/set-quota", json={"message": "Quota updated."})
+        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "a@t.com", "-s", "10mb"])
+        assert result.exit_code == 0
+        assert "updated" in result.output.lower()
+
+
+def _query_of(url: str) -> dict:
+    from urllib.parse import parse_qs, urlparse
+    return {k: v[0] for k, v in parse_qs(urlparse(url).query).items()}
+
+
+def _get_calls(mock_router, path_suffix: str) -> list:
+    return [
+        c for c in mock_router.calls
+        if c["method"] == "GET" and path_suffix in c["url"].split("?")[0]
+    ]
+
+
+class TestAdminRun:
+    def test_not_top_level(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "run", "list", "-e", "alice@test.com"])
+        assert result.exit_code != 0
+
+    def test_help_lists_read_commands(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "user-info", "--help"])
+        assert result.exit_code == 0
+        assert "run" in result.output
+        assert "files" in result.output
+
+    def test_run_help_is_read_only(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "user-info", "run", "--help"])
+        assert result.exit_code == 0
+        assert "list" in result.output
+        assert "status" in result.output
+        assert "submit" not in result.output
+        assert "cancel" not in result.output
+
+    def test_submit_not_a_command(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "run", "submit", "-e", "alice@test.com", "model.py"]
+        )
+        assert result.exit_code != 0
+
+    def test_list_sends_as_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/list", json={"analyses": [], "as_user": "alice@test.com"})
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "run", "list", "-e", "alice@test.com", "--all"]
+        )
+        assert result.exit_code == 0
+        calls = _get_calls(mock_router, "/prod/run/list")
+        assert calls
+        assert _query_of(calls[0]["url"])["as_user"] == "alice@test.com"
+
+    def test_list_parent_email(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/list", json={"analyses": [], "as_user": "alice@test.com"})
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "-e", "alice@test.com", "run", "list", "--all"]
+        )
+        assert result.exit_code == 0
+        calls = _get_calls(mock_router, "/prod/run/list")
+        assert calls
+        assert _query_of(calls[0]["url"])["as_user"] == "alice@test.com"
+
+    def test_list_requires_email(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "user-info", "run", "list"])
+        assert result.exit_code != 0
+
+    def test_status_sends_as_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/status", json={
+            "task_id": "ttt55555",
+            "analysis_id": "aaa55555",
+            "status": "completed",
+            "filename": "model.py",
+            "type": "fast",
+            "total_tasks": 1,
+            "as_user": "alice@test.com",
+        })
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "run", "status", "aaa55555", "-e", "alice@test.com"]
+        )
+        assert result.exit_code == 0
+        calls = _get_calls(mock_router, "/prod/run/status")
+        assert calls
+        q = _query_of(calls[0]["url"])
+        assert q["as_user"] == "alice@test.com"
+        assert q["id"] == "aaa55555"
+
+
+class TestAdminFiles:
+    def test_not_top_level(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "files", "list", "-e", "alice@test.com"])
+        assert result.exit_code != 0
+
+    def test_help_is_read_only(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["admin", "user-info", "files", "--help"])
+        assert result.exit_code == 0
+        assert "list" in result.output
+        assert "download" in result.output
+        assert "upload" not in result.output
+        assert "delete" not in result.output
+
+    def test_list_sends_as_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/files/list", json={
+            "files": [{"path": "model.py", "size": 10, "last_modified": "2026-01-01T00:00:00Z"}],
+            "as_user": "alice@test.com",
+        })
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "files", "list", "-e", "alice@test.com"]
+        )
+        assert result.exit_code == 0
+        assert "model.py" in result.output
+        calls = _get_calls(mock_router, "/prod/files/list")
+        assert calls
+        assert _query_of(calls[0]["url"])["as_user"] == "alice@test.com"
+        assert "Files for alice@test.com" in result.output
+
+    def test_list_old_api_does_not_show_caller_files(
+        self, cli_runner, admin_creds, patch_httpx, mock_router
+    ):
+        mock_router.add("GET", "/prod/files/list", json={
+            "files": [{"path": "mine.py", "size": 10, "last_modified": "2026-01-01T00:00:00Z"}],
+        })
+        result = cli_runner.invoke(
+            app, ["admin", "user-info", "files", "list", "-e", "alice@test.com"]
+        )
+        assert result.exit_code == 1
+        assert "mine.py" not in result.output
+        assert "Deploy the API" in result.output
+
+    def test_download_sends_as_user(self, cli_runner, admin_creds, patch_httpx, mock_router, tmp_path):
+        mock_router.add("GET", "/prod/files/list", json={
+            "files": [{"path": "model.py", "size": 5, "last_modified": "2026-01-01T00:00:00Z"}],
+            "as_user": "alice@test.com",
+        })
+        mock_router.add("GET", "/prod/files/download", json={
+            "download_url": "https://s3.example.com/presigned-get?sig=abc",
+            "as_user": "alice@test.com",
+        })
+        mock_router.add_any_url("GET", status=200, content=b"hello")
+        out = tmp_path / "model.py"
+        result = cli_runner.invoke(
+            app,
+            ["admin", "user-info", "files", "download", "model.py", "-e", "alice@test.com", "-o", str(out)],
+        )
+        assert result.exit_code == 0
+        list_calls = _get_calls(mock_router, "/prod/files/list")
+        dl_calls = _get_calls(mock_router, "/prod/files/download")
+        assert list_calls and dl_calls
+        assert _query_of(list_calls[0]["url"])["as_user"] == "alice@test.com"
+        assert _query_of(dl_calls[0]["url"])["as_user"] == "alice@test.com"

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/tests/test_api.py

@@ -8,6 +8,7 @@ import pytest
 from opensees_cli.api import (
     ApiError,
     _parse,
+    acting_as,
     post,
     get,
     upload_file,
@@ -248,3 +249,24 @@ class TestFetchS3Range:
         data, complete = fetch_s3_range("https://s3.example.com/stdout?sig=abc")
         assert data == b""
         assert complete is False
+
+
+class TestActingAs:
+    def test_get_includes_as_user(self, logged_in_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/list", json={"analyses": [], "as_user": "alice@test.com"})
+        with acting_as("Alice@Test.com"):
+            get("/run/list")
+        urls = [c["url"] for c in mock_router.calls if "/prod/run/list" in c["url"]]
+        assert urls
+        assert "as_user=alice%40test.com" in urls[0]
+
+    def test_get_clears_after_context(self, logged_in_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/list", json={"analyses": [], "as_user": "alice@test.com"})
+        with acting_as("alice@test.com"):
+            get("/run/list")
+        mock_router.add("GET", "/prod/run/list", json={"analyses": []})
+        get("/run/list")
+        urls = [c["url"] for c in mock_router.calls if "/prod/run/list" in c["url"]]
+        assert len(urls) == 2
+        assert "as_user" in urls[0]
+        assert "as_user" not in urls[1]

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/tests/test_auth_commands.py

@@ -5,6 +5,7 @@ from unittest.mock import patch
 
 from opensees_cli.auth import app as auth_app
 from opensees_cli.main import app
+from opensees_cli.auth import maybe_print_cli_upgrade
 
 
 def _patch_password(*passwords):
@@ -93,12 +94,15 @@ class TestLogin:
         assert result.exit_code == 0
         assert "Logged in" in result.output
 
-    def test_login_bad_credentials(self, cli_runner, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/auth/login", status=400, json={"error": "Incorrect username or password."})
-        with patch("opensees_cli.auth._ask_password", return_value="wrong"):
+    def test_login_stale_cli(self, cli_runner, patch_httpx, mock_router):
+        mock_router.add("POST", "/prod/auth/login", status=400, json={
+            "error": "This CLI (0.2.3) is out of date. Upgrade with: pip install -U opensees_cli",
+            "code": "auth_error",
+        })
+        with patch("opensees_cli.auth._ask_password", return_value="Pass1!"):
             result = cli_runner.invoke(app, ["auth", "login", "-e", "u@t.com"])
         assert result.exit_code == 1
-        assert "Incorrect" in result.output
+        assert "pip install -U opensees_cli" in result.output
 
 
 class TestLogout:
@@ -165,3 +169,16 @@ class TestChangePassword:
             result = cli_runner.invoke(app, ["auth", "change-password"])
         assert result.exit_code == 1
         assert "do not match" in result.output
+
+
+class TestCliUpgradeNag:
+    def test_prints_when_behind(self, capsys):
+        maybe_print_cli_upgrade(latest="99.0.0")
+        out = capsys.readouterr().out
+        assert "pip install -U opensees_cli" in out
+        assert "99.0.0" in out
+
+    def test_silent_when_current(self, capsys):
+        from opensees_cli import __version__
+        maybe_print_cli_upgrade(latest=__version__)
+        assert capsys.readouterr().out == ""

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/tests/test_config.py

@@ -8,6 +8,8 @@ from opensees_cli.config import (
     get_refresh_token,
     get_api_url,
     is_admin,
+    is_older_version,
+    version_tuple,
 )
 
 
@@ -82,3 +84,14 @@ class TestApiUrl:
     def test_env_override(self, monkeypatch):
         monkeypatch.setenv("OPENSEES_API_URL", "https://custom.example/v1")
         assert get_api_url() == "https://custom.example/v1"
+
+
+class TestVersionCompare:
+    def test_older(self):
+        assert is_older_version("0.2.1", "0.2.3")
+        assert not is_older_version("0.2.3", "0.2.3")
+        assert not is_older_version("0.2.4", "0.2.3")
+
+    def test_non_numeric_prefix(self):
+        assert version_tuple("web/1.0.0") == (1, 0, 0)
+        assert not is_older_version("web/1.0.0", "0.2.3")

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/tests/test_files_commands.py

@@ -15,6 +15,10 @@ class TestFilesList:
         assert result.exit_code == 0
         assert result.output == ""
 
+    def test_list_rejects_user_flag(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["files", "list", "--user", "alice@test.com"])
+        assert result.exit_code != 0
+
     def test_list_with_files(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
         mock_router.add("GET", "/prod/files/list", json={
             "files": [

{opensees_cli-0.2.2 → opensees_cli-0.2.4}/tests/test_run_commands.py

@@ -342,3 +342,16 @@ class TestList:
         result = cli_runner.invoke(app, ["run", "list"])
         assert result.exit_code == 0
         assert "No analyses" in result.output
+
+    def test_list_rejects_user_flag(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
+        result = cli_runner.invoke(app, ["run", "list", "--user", "alice@test.com"])
+        assert result.exit_code != 0
+        assert "as_user" not in " ".join(c["url"] for c in mock_router.calls)
+
+    def test_list_does_not_send_as_user(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/list", json={"analyses": []})
+        result = cli_runner.invoke(app, ["run", "list", "--all"])
+        assert result.exit_code == 0
+        urls = [c["url"] for c in mock_router.calls if "/prod/run/list" in c["url"]]
+        assert urls
+        assert "as_user" not in urls[0]

opensees_cli-0.2.2/tests/test_admin_commands.py

@@ -1,150 +0,0 @@
-"""Tests for ops admin subcommands — one test per command, using admin creds."""
-
-from unittest.mock import patch
-
-from opensees_cli.main import app
-
-
-class TestListUsers:
-    def test_list_users(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("GET", "/prod/admin/users", json={
-            "users": [
-                {
-                    "email": "alice@test.com",
-                    "status": "CONFIRMED",
-                    "enabled": True,
-                    "is_admin": False,
-                    "last_login_at": "2025-01-01T00:00:00Z",
-                    "last_activity_at": "",
-                    "openseespy_version": "3.7.1.0",
-                },
-            ]
-        })
-        result = cli_runner.invoke(app, ["admin", "list-users"])
-        assert result.exit_code == 0
-        assert "alice@te" in result.output
-        assert "3.7.1.0" in result.output
-        assert "CLI Version" not in result.output
-        assert "Pinned" in result.output
-
-    def test_list_users_empty(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("GET", "/prod/admin/users", json={"users": []})
-        result = cli_runner.invoke(app, ["admin", "list-users"])
-        assert result.exit_code == 0
-        assert "No users" in result.output
-
-
-class TestDisableUser:
-    def test_disable_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/disable-user", json={"message": "User disabled."})
-        result = cli_runner.invoke(app, ["admin", "disable-user", "-e", "alice@test.com"])
-        assert result.exit_code == 0
-        assert "disabled" in result.output.lower()
-
-
-class TestEnableUser:
-    def test_enable_user(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/enable-user", json={"message": "User enabled."})
-        result = cli_runner.invoke(app, ["admin", "enable-user", "-e", "alice@test.com"])
-        assert result.exit_code == 0
-        assert "enabled" in result.output.lower()
-
-
-class TestDeleteUser:
-    def test_delete_user_confirmed(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/delete-user", json={"message": "User deleted."})
-        result = cli_runner.invoke(app, ["admin", "delete-user", "-e", "alice@test.com"], input="y\n")
-        assert result.exit_code == 0
-        assert "deleted" in result.output.lower()
-
-    def test_delete_user_cancelled(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        result = cli_runner.invoke(app, ["admin", "delete-user", "-e", "alice@test.com"], input="n\n")
-        assert result.exit_code == 0
-        assert "Cancelled" in result.output
-
-
-class TestUserInfo:
-    def test_user_info(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/user-info", json={
-            "email": "alice@test.com",
-            "is_admin": False,
-            "is_enabled": True,
-            "openseespy_version": "3.7.1.0",
-            "quota": {
-                "max_concurrent_runs": 5,
-                "max_tasks_per_analysis": 100,
-                "max_monthly_runtime": 3600,
-                "monthly_runtime_used": 0,
-                "monthly_runtime_remaining": 3600,
-                "max_monthly_storage": 1073741824,
-                "storage_used": 0,
-            },
-            "analyses_total": 2,
-            "analyses_running": 1,
-            "analyses": [
-                {
-                    "analysis_id": "aaa11111-0000-0000-0000-000000000000",
-                    "status": "running",
-                    "filename": "Truss.py",
-                    "type": "fast",
-                    "total_tasks": 1,
-                    "created_at": "2026-09-01T00:00:00Z",
-                },
-            ],
-            "files_total": 1,
-            "files_size": 128,
-            "files": [
-                {"path": "Truss.py", "size": 128, "last_modified": "2026-09-01T00:00:00Z"},
-            ],
-        })
-        result = cli_runner.invoke(app, ["admin", "user-info", "-e", "alice@test.com"])
-        assert result.exit_code == 0
-        assert "alice@test.com" in result.output
-        assert "3.7.1.0" in result.output
-        assert "pinned" in result.output.lower()
-        assert "Truss.py" in result.output
-        assert "Analyses" in result.output
-        assert "Files" in result.output
-
-    def test_user_info_not_pinned(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/user-info", json={
-            "email": "bob@test.com",
-            "is_admin": False,
-            "is_enabled": True,
-            "openseespy_version": None,
-            "analyses_total": 0,
-            "analyses_running": 0,
-            "analyses": [],
-            "files_total": 0,
-            "files_size": 0,
-            "files": [],
-        })
-        result = cli_runner.invoke(app, ["admin", "user-info", "-e", "bob@test.com"])
-        assert result.exit_code == 0
-        assert "not pinned" in result.output.lower()
-        assert "No analyses" in result.output
-        assert "No files" in result.output
-
-
-class TestSetQuota:
-    def test_set_quota_runtime(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/set-quota", json={"message": "Quota updated."})
-        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "alice@test.com", "-r", "2h"])
-        assert result.exit_code == 0
-        assert "updated" in result.output.lower()
-
-    def test_set_quota_no_flags(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "alice@test.com"])
-        assert result.exit_code == 0
-        assert "Provide at least one" in result.output
-
-    def test_set_quota_invalid_runtime(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "a@t.com", "-r", "abc"])
-        assert result.exit_code == 1
-        assert "Invalid" in result.output
-
-    def test_set_quota_storage(self, cli_runner, admin_creds, patch_httpx, mock_router):
-        mock_router.add("POST", "/prod/admin/set-quota", json={"message": "Quota updated."})
-        result = cli_runner.invoke(app, ["admin", "set-quota", "-e", "a@t.com", "-s", "10mb"])
-        assert result.exit_code == 0
-        assert "updated" in result.output.lower()