opensees-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: Run OpenSees simulations in the cloud from the command line.
 Author: Minjie Zhu
 License: Proprietary
@@ -121,7 +121,7 @@ ops run help
 Validation enforced by CLI (local uploads):
 - path must exist on disk and be a regular file
 - file extension must be `.py`
-- file size must be <= 200 KB
+- upload uses the cloud file API (same as `ops files upload`; up to 100 MB per file)
 
 ## Common Workflows
 

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/README.md

@@ -98,7 +98,7 @@ ops run help
 Validation enforced by CLI (local uploads):
 - path must exist on disk and be a regular file
 - file extension must be `.py`
-- file size must be <= 200 KB
+- upload uses the cloud file API (same as `ops files upload`; up to 100 MB per file)
 
 ## Common Workflows
 

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/pyproject.toml

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

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli/__init__.py

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

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/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
@@ -12,6 +13,14 @@ from typer.core import TyperGroup
 
 from opensees_cli import 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))+$")
 
@@ -113,7 +122,7 @@ def list_users():
     table.add_column("Admin")
     table.add_column("Last Login")
     table.add_column("Last Activity")
-    table.add_column("CLI Version")
+    table.add_column("Pinned")
 
     for u in users:
         enabled = "[green]yes[/green]" if u.get("enabled") else "[red]no[/red]"
@@ -125,7 +134,7 @@ def list_users():
             admin,
             u.get("last_login_at", "") or "-",
             u.get("last_activity_at", "") or "-",
-            u.get("last_cli_version", "") or "-",
+            u.get("openseespy_version", "") or "-",
         )
     console.print(table)
 
@@ -175,11 +184,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 and quota."""
-    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:
@@ -195,8 +200,11 @@ def user_info(email: Optional[str] = typer.Option(None, "--email", "-e")):
         console.print(f"  Last login:   {_to_local(r['last_login_at'])}")
     if r.get("last_activity_at"):
         console.print(f"  Last active:  {_to_local(r['last_activity_at'])}")
-    if r.get("last_cli_version"):
-        console.print(f"  CLI version:  {r['last_cli_version']}")
+    pin = r.get("openseespy_version") or ""
+    if pin:
+        console.print(f"  OpenSeesPy:   {pin} (pinned)")
+    else:
+        console.print("  OpenSeesPy:   [dim]-[/dim] (not pinned)")
     if r.get("last_ip"):
         console.print(f"  Last IP:      {r['last_ip']}")
 
@@ -354,3 +362,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.1 → opensees_cli-0.2.3}/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.1 → opensees_cli-0.2.3}/src/opensees_cli/auth.py

@@ -460,7 +460,12 @@ def login(email: Optional[str] = typer.Option(None, "--email", "-e")):
         from opensees_cli import __version__
         r = api.post(
             "/auth/login",
-            {"email": email, "password": password, "cli_version": __version__},
+            {
+                "email": email,
+                "password": password,
+                "cli_version": __version__,
+                "openseespy_version": config.get_openseespy_version() or "",
+            },
             auth=False,
         )
         config.save_credentials(

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli/main.py

@@ -140,7 +140,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")

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli/run.py

@@ -739,6 +739,7 @@ def status(
                 "analysis_id": aid,
                 "status": a.get("status"),
                 "filename": a.get("filename"),
+                "type": _run_type(a),
                 "total_tasks": total_tasks,
                 "completed_tasks": completed,
                 "failed_tasks": failed,
@@ -758,6 +759,7 @@ def status(
     table = Table(show_header=True, title="Running analyses")
     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")
@@ -773,6 +775,7 @@ def status(
         table.add_row(
             aid,
             _status_style(a.get("status", "")),
+            _run_type(a),
             a.get("filename", ""),
             tasks_str,
             _to_local(a.get("created_at", "")) if a.get("created_at") else "",
@@ -1971,6 +1974,23 @@ def _status_style(s: str) -> str:
     return styles.get(s, s)
 
 
+_LAMBDA_MAX_TIMEOUT = 900
+
+
+def _run_type(r: dict) -> str:
+    """Worker type shown to users: ``fast`` (Lambda) or ``long`` (Fargate)."""
+    t = r.get("type")
+    if t in ("fast", "long"):
+        return t
+    timeout = r.get("timeout")
+    if timeout is not None:
+        try:
+            return "long" if int(timeout) > _LAMBDA_MAX_TIMEOUT else "fast"
+        except (TypeError, ValueError):
+            pass
+    return ""
+
+
 def _print_status(r: dict) -> None:
     """Print analysis summary, per-task list, or individual task detail."""
     # Multi-task analysis
@@ -1978,6 +1998,9 @@ def _print_status(r: dict) -> None:
         analysis_id = r.get("analysis_id", "")
         console.print(f"  Analysis: [dim]{analysis_id}[/dim]")
         console.print(f"  File:     {r.get('filename', '')}")
+        run_type = _run_type(r)
+        if run_type:
+            console.print(f"  Type:     {run_type}")
         total = r["total_tasks"]
         completed = r.get("completed", 0)
         failed = r.get("failed", 0)
@@ -2031,6 +2054,9 @@ def _print_status(r: dict) -> None:
         console.print(f"  Analysis: [dim]{analysis_id}[/dim]")
 
     console.print(f"  Status:   {_status_style(r.get('status', ''))}")
+    run_type = _run_type(r)
+    if run_type:
+        console.print(f"  Type:     {run_type}")
     if r.get("filename"):
         console.print(f"  File:     {r['filename']}")
     if r.get("created_at"):

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli/version.py

@@ -9,6 +9,18 @@ from rich.table import Table
 from opensees_cli import api, config
 
 console = Console()
+
+
+def _sync_pin_to_server(version: Optional[str]) -> None:
+    """Best-effort: store the local pin on the user record for admin list-users."""
+    if not api.has_stored_credentials():
+        return
+    try:
+        api.post("/auth/me", {"openseespy_version": version or ""})
+    except api.ApiError:
+        pass
+
+
 app = typer.Typer(
     name="version",
     help="Manage OpenSeesPy versions",
@@ -43,6 +55,7 @@ def set_version(version: str):
         console.print(f"[yellow]Warning: could not verify version: {e.message}[/yellow]")
 
     config.set_openseespy_version(version)
+    _sync_pin_to_server(version)
     console.print(f"[green]OpenSeesPy version pinned to: {version}[/green]")
 
 
@@ -74,6 +87,24 @@ def get_version():
         raise typer.Exit(1)
 
 
+def _status_label(v: dict) -> str:
+    """Human status for the list table. Partial rows are numbered, not named.
+
+    ``partial 1`` — only the first worker is registered (Lambda).
+    ``partial 2`` — only the second worker is registered (Fargate).
+    """
+    status = (v.get("status") or "").strip() or "unknown"
+    if status != "partial":
+        return status
+    has_first = bool(v.get("lambda_arn"))
+    has_second = bool(v.get("fargate_task_def"))
+    if has_first and not has_second:
+        return "partial 1"
+    if has_second and not has_first:
+        return "partial 2"
+    return "partial"
+
+
 @app.command("list")
 def list_versions(
     status: str = typer.Option(
@@ -82,12 +113,6 @@ def list_versions(
         "-s",
         help="Filter by status: active, inactive, partial",
     ),
-    show_arns: bool = typer.Option(
-        False,
-        "--arns",
-        "-a",
-        help="Show Lambda and Fargate ARNs",
-    ),
 ):
     """
     List available OpenSeesPy versions in the registry.
@@ -95,7 +120,6 @@ def list_versions(
     Example:
         ops version list
         ops version list --status active
-        ops version list --arns
     """
     try:
         params = {}
@@ -118,9 +142,6 @@ def list_versions(
     table.add_column("Version")
     table.add_column("Status")
     table.add_column("Updated")
-    if show_arns:
-        table.add_column("Lambda ARN", overflow="fold")
-        table.add_column("Fargate Task Def", overflow="fold")
 
     for v in versions:
         version_str = v["version"]
@@ -132,7 +153,7 @@ def list_versions(
         if tags:
             version_str = f"[bold green]{version_str} ({', '.join(tags)})[/bold green]"
 
-        status_str = v["status"]
+        status_str = _status_label(v)
         if status_str == "active":
             status_str = f"[green]{status_str}[/green]"
         elif status_str == "inactive":
@@ -144,12 +165,7 @@ def list_versions(
         if updated:
             updated = updated.split("T")[0]
 
-        row = [version_str, status_str, updated]
-        if show_arns:
-            row.append(v.get("lambda_arn", ""))
-            row.append(v.get("fargate_task_def", ""))
-
-        table.add_row(*row)
+        table.add_row(version_str, status_str, updated)
 
     console.print(table)
 
@@ -165,6 +181,7 @@ def clear_version():
         ops version clear
     """
     config.clear_openseespy_version()
+    _sync_pin_to_server(None)
     console.print("[green]Pin cleared — will use API default (latest active)[/green]")
 
 

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: Run OpenSees simulations in the cloud from the command line.
 Author: Minjie Zhu
 License: Proprietary
@@ -121,7 +121,7 @@ ops run help
 Validation enforced by CLI (local uploads):
 - path must exist on disk and be a regular file
 - file extension must be `.py`
-- file size must be <= 200 KB
+- upload uses the cloud file API (same as `ops files upload`; up to 100 MB per file)
 
 ## Common Workflows
 

{opensees_cli-0.2.1 → opensees_cli-0.2.3}/src/opensees_cli.egg-info/SOURCES.txt

@@ -23,4 +23,5 @@ tests/test_auth_commands.py
 tests/test_config.py
 tests/test_files_commands.py
 tests/test_main_commands.py
-tests/test_run_commands.py
+tests/test_run_commands.py
+tests/test_version_commands.py

opensees_cli-0.2.3/tests/test_admin_commands.py

@@ -0,0 +1,291 @@
+"""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",
+            "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 "CLI version" not 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.1 → opensees_cli-0.2.3}/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.1 → opensees_cli-0.2.3}/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.1 → opensees_cli-0.2.3}/tests/test_run_commands.py

@@ -183,6 +183,7 @@ class TestRunStatus:
             "analysis_id": "aaa55555",
             "status": "completed",
             "filename": "model.py",
+            "type": "fast",
             "total_tasks": 1,
             "created_at": "2025-06-01T00:00:00Z",
             "runtime_seconds": 12.5,
@@ -191,6 +192,26 @@ class TestRunStatus:
         result = cli_runner.invoke(app, ["run", "status", "aaa55555"])
         assert result.exit_code == 0
         assert "completed" in result.output.lower()
+        assert "Type:" in result.output
+        assert "fast" in result.output
+        assert "lambda" not in result.output.lower()
+        assert "fargate" not in result.output.lower()
+
+    def test_status_long_type(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/run/status", json={
+            "task_id": "ttt55556",
+            "analysis_id": "aaa55556",
+            "status": "running",
+            "filename": "model.py",
+            "type": "long",
+            "timeout": 1800,
+            "total_tasks": 1,
+        })
+        result = cli_runner.invoke(app, ["run", "status", "aaa55556"])
+        assert result.exit_code == 0
+        assert "Type:" in result.output
+        assert "long" in result.output
+        assert "fargate" not in result.output.lower()
 
     def test_status_no_running(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
         mock_router.add("GET", "/prod/run/list", json={"analyses": []})
@@ -321,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.3/tests/test_version_commands.py

@@ -0,0 +1,72 @@
+"""Tests for ops version list status labels."""
+
+from opensees_cli.main import app
+from opensees_cli.version import _status_label
+
+
+def test_status_label_partial_1():
+    assert _status_label({
+        "status": "partial",
+        "lambda_arn": "arn:aws:lambda:us-west-2:1:function:opensees",
+        "fargate_task_def": "",
+    }) == "partial 1"
+
+
+def test_status_label_partial_2():
+    assert _status_label({
+        "status": "partial",
+        "lambda_arn": "",
+        "fargate_task_def": "arn:aws:ecs:us-west-2:1:task-definition/opensees:1",
+    }) == "partial 2"
+
+
+def test_status_label_active_and_inactive():
+    assert _status_label({"status": "active", "lambda_arn": "x", "fargate_task_def": "y"}) == "active"
+    assert _status_label({"status": "inactive"}) == "inactive"
+
+
+def test_version_list_shows_partial_numbers(cli_runner, patch_httpx, mock_router):
+    mock_router.add("GET", "/prod/run/versions", json={
+        "default": "3.7.0.0",
+        "versions": [
+            {
+                "version": "3.7.0.0",
+                "status": "active",
+                "lambda_arn": "arn:aws:lambda:fn-a",
+                "fargate_task_def": "arn:aws:ecs:td-a",
+                "updated_at": "2026-09-01T00:00:00Z",
+                "is_default": True,
+            },
+            {
+                "version": "3.6.0.0",
+                "status": "partial",
+                "lambda_arn": "arn:aws:lambda:fn-b",
+                "fargate_task_def": "",
+                "updated_at": "2026-08-01T00:00:00Z",
+            },
+            {
+                "version": "3.5.0.0",
+                "status": "partial",
+                "lambda_arn": "",
+                "fargate_task_def": "arn:aws:ecs:td-c",
+                "updated_at": "2026-07-01T00:00:00Z",
+            },
+        ],
+    })
+    result = cli_runner.invoke(app, ["version", "list"])
+    assert result.exit_code == 0
+    assert "partial 1" in result.output
+    assert "partial 2" in result.output
+    assert "active" in result.output
+    assert "arn:aws:lambda" not in result.output
+    assert "arn:aws:ecs" not in result.output
+    assert "Lambda" not in result.output
+    assert "Fargate" not in result.output
+
+
+def test_version_list_rejects_arns_flag(cli_runner, patch_httpx, mock_router):
+    result = cli_runner.invoke(app, ["version", "list", "-a"])
+    assert result.exit_code != 0
+    assert "No such option" in result.output or "no such option" in result.output.lower()
+    result = cli_runner.invoke(app, ["version", "list", "--arns"])
+    assert result.exit_code != 0

opensees_cli-0.2.1/tests/test_admin_commands.py

@@ -1,105 +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": "",
-                    "last_cli_version": "0.1.0a2",
-                },
-            ]
-        })
-        result = cli_runner.invoke(app, ["admin", "list-users"])
-        assert result.exit_code == 0
-        assert "alice@te" 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,
-            "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,
-            },
-        })
-        result = cli_runner.invoke(app, ["admin", "user-info", "-e", "alice@test.com"])
-        assert result.exit_code == 0
-        assert "alice@test.com" 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()