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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.0
+Version: 0.2.2
 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.0 → opensees_cli-0.2.2}/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.0 → opensees_cli-0.2.2}/pyproject.toml

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

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

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

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

@@ -11,7 +11,7 @@ from rich.table import Table
 from typer.core import TyperGroup
 
 from opensees_cli import api, config
-from opensees_cli.auth import _to_local, print_quota
+from opensees_cli.auth import _to_local, _fmt_bytes, print_quota
 
 _RUNTIME_TOKEN_RE = re.compile(r"^((\d+(?:\.\d+)?)(h|m|s))+$")
 
@@ -113,7 +113,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 +125,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)
 
@@ -177,7 +177,7 @@ def delete_user(email: Optional[str] = typer.Option(None, "--email", "-e")):
 
 @app.command("user-info")
 def user_info(email: Optional[str] = typer.Option(None, "--email", "-e")):
-    """Show a user's account details and quota."""
+    """Show a user's account details, quota, analyses, and files."""
     if not email:
         email = typer.prompt("Email")
     try:
@@ -195,6 +195,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'])}")
+    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_cli_version"):
         console.print(f"  CLI version:  {r['last_cli_version']}")
     if r.get("last_ip"):
@@ -205,6 +210,62 @@ 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(

{opensees_cli-0.2.0 → opensees_cli-0.2.2}/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.0 → opensees_cli-0.2.2}/src/opensees_cli/files.py

@@ -28,14 +28,35 @@ def _files_callback(ctx: typer.Context) -> None:
         raise typer.Exit(0)
 
 
-def _files_list_items() -> list[dict]:
-    """All files in the user file system."""
-    r = api.get("/files/list")
+def _files_list_items(folder: Optional[str] = None) -> list[dict]:
+    """List files in the user file system, optionally under ``folder``."""
+    params = {}
+    if folder:
+        params["folder"] = folder.strip().strip("/")
+    r = api.get("/files/list", params=params or None)
     return list(r.get("files", []))
 
 
+def _filter_under_folder(items: list[dict], folder: str) -> list[dict]:
+    """Keep files at or under ``folder`` (client-side fallback)."""
+    root = folder.strip().strip("/")
+    if not root:
+        return items
+    prefix = root + "/"
+    out = []
+    for f in items:
+        path = str(f.get("path", ""))
+        if path == root or path.startswith(prefix):
+            out.append(f)
+    return out
+
+
 @app.command("list")
 def list_files(
+    folder: Optional[str] = typer.Argument(
+        None,
+        help="Only list files in this folder (and its subfolders), e.g. truss or examples/dambreak",
+    ),
     as_json: bool = typer.Option(
         False,
         "--json",
@@ -44,9 +65,12 @@ def list_files(
         is_flag=True,
     ),
 ):
-    """List files. Prints nothing on stdout when there are no files (non-JSON)."""
+    """List files. With FOLDER, only show files under that path. Prints nothing when empty (non-JSON)."""
     try:
-        items = _files_list_items()
+        items = _files_list_items(folder)
+        # Older APIs ignore ?folder= — filter locally so the CLI still works.
+        if folder:
+            items = _filter_under_folder(items, folder)
     except api.ApiError as e:
         console.print(f"[red]{e.message}[/red]")
         raise typer.Exit(1)
@@ -66,6 +90,8 @@ def list_files(
             "file_count": len(rows),
             "total_size": total,
         }
+        if folder:
+            obj["folder"] = folder.strip().strip("/")
         typer.echo(json.dumps(obj, indent=2).rstrip("\n"))
         return
 

{opensees_cli-0.2.0 → opensees_cli-0.2.2}/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 "",
@@ -1093,32 +1096,39 @@ def _week_range(week: int) -> tuple[datetime, datetime]:
     return start.astimezone(timezone.utc), end.astimezone(timezone.utc)
 
 
-def _fmt_date_span(after_dt: datetime, before_dt: datetime | None) -> str:
+def _fmt_date_span(after_dt: datetime, before_dt: Optional[datetime]) -> str:
     """Return a compact human-readable date span string in local time.
 
     ``before_dt`` is exclusive (the day after the last day), so we display
     ``before_dt - 1 day`` as the end date.  If ``before_dt`` is ``None`` the
     end is displayed as "today".
     Example: "Jan 5 – Mar 8, 2026" or "May 4–10, 2026" (same year/month).
+
+    Avoids ``%-d`` / ``%#d`` strftime flags (Unix vs Windows) by formatting
+    the day with ``dt.day`` instead.
     """
+    def _md(dt: datetime, *, year: bool = False) -> str:
+        s = f"{dt.strftime('%b')} {dt.day}"
+        return f"{s}, {dt.year}" if year else s
+
     local = datetime.now().astimezone().tzinfo
     start = after_dt.astimezone(local)
 
     if before_dt is None:
         end = datetime.now().astimezone(local)
-        end_str = f"{end.strftime('%b %-d, %Y')}"
+        end_str = _md(end, year=True)
         if start.year == end.year:
             if start.month == end.month:
-                return f"{start.strftime('%b %-d')}–{end.strftime('%-d, %Y')}"
-            return f"{start.strftime('%b %-d')} – {end_str}"
-        return f"{start.strftime('%b %-d, %Y')} – {end_str}"
+                return f"{_md(start)}–{end.day}, {end.year}"
+            return f"{_md(start)} – {end_str}"
+        return f"{_md(start, year=True)} – {end_str}"
 
     end = (before_dt - timedelta(seconds=1)).astimezone(local)
     if start.year == end.year:
         if start.month == end.month:
-            return f"{start.strftime('%b %-d')}–{end.strftime('%-d, %Y')}"
-        return f"{start.strftime('%b %-d')} – {end.strftime('%b %-d, %Y')}"
-    return f"{start.strftime('%b %-d, %Y')} – {end.strftime('%b %-d, %Y')}"
+            return f"{_md(start)}–{end.day}, {end.year}"
+        return f"{_md(start)} – {_md(end, year=True)}"
+    return f"{_md(start, year=True)} – {_md(end, year=True)}"
 
 
 def _week_span_range(w1: int, w2: int) -> tuple[datetime, datetime]:
@@ -1964,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
@@ -1971,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)
@@ -2024,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.0 → opensees_cli-0.2.2}/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.0 → opensees_cli-0.2.2}/src/opensees_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensees_cli
-Version: 0.2.0
+Version: 0.2.2
 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.0 → opensees_cli-0.2.2}/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.0 → opensees_cli-0.2.2}/tests/test_admin_commands.py

@@ -16,13 +16,16 @@ class TestListUsers:
                     "is_admin": False,
                     "last_login_at": "2025-01-01T00:00:00Z",
                     "last_activity_at": "",
-                    "last_cli_version": "0.1.0a2",
+                    "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": []})
@@ -66,6 +69,7 @@ class TestUserInfo:
             "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,
@@ -75,10 +79,51 @@ class TestUserInfo:
                 "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:

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

@@ -27,6 +27,20 @@ class TestFilesList:
         assert "model.py" in result.output
         assert "data.csv" in result.output
 
+    def test_list_folder_filters(self, cli_runner, logged_in_creds, patch_httpx, mock_router):
+        mock_router.add("GET", "/prod/files/list", json={
+            "files": [
+                {"path": "truss/Truss.py", "size": 100, "last_modified": "2025-01-01T00:00:00Z"},
+                {"path": "truss/data.csv", "size": 200, "last_modified": "2025-01-01T00:00:00Z"},
+                {"path": "other/model.py", "size": 300, "last_modified": "2025-01-01T00:00:00Z"},
+            ]
+        })
+        result = cli_runner.invoke(app, ["files", "list", "truss"])
+        assert result.exit_code == 0
+        assert "truss/Truss.py" in result.output
+        assert "truss/data.csv" in result.output
+        assert "other/model.py" not in result.output
+
 
 class TestFilesUpload:
     def test_upload_single_file(self, cli_runner, logged_in_creds, patch_httpx, mock_router, tmp_file):

{opensees_cli-0.2.0 → opensees_cli-0.2.2}/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": []})

opensees_cli-0.2.2/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