meshagent-cli 0.38.2__tar.gz → 0.38.4__tar.gz

{meshagent_cli-0.38.2/meshagent_cli.egg-info → meshagent_cli-0.38.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.38.2
+Version: 0.38.4
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -19,26 +19,27 @@ Requires-Dist: pyyaml~=6.0.2
 Requires-Dist: pydantic-yaml~=1.5
 Requires-Dist: pathspec<2,>=1.0.3
 Requires-Dist: zstandard~=0.25.0
-Requires-Dist: meshagent-llm-proxy==0.38.2
+Requires-Dist: meshagent-llm-proxy==0.38.4
 Requires-Dist: rich~=14.3.0
 Requires-Dist: textual<9.0,>=8.2.3
 Requires-Dist: prompt-toolkit~=3.0.52
 Provides-Extra: all
-Requires-Dist: meshagent-agents[all]==0.38.2; extra == "all"
-Requires-Dist: meshagent-api[all]==0.38.2; extra == "all"
-Requires-Dist: meshagent-computers==0.38.2; extra == "all"
-Requires-Dist: meshagent-openai==0.38.2; extra == "all"
-Requires-Dist: meshagent-anthropic==0.38.2; extra == "all"
-Requires-Dist: meshagent-codex==0.38.2; extra == "all"
-Requires-Dist: meshagent-mcp==0.38.2; extra == "all"
-Requires-Dist: meshagent-tools==0.38.2; extra == "all"
+Requires-Dist: meshagent-agents[all]==0.38.4; extra == "all"
+Requires-Dist: meshagent-api[all]==0.38.4; extra == "all"
+Requires-Dist: meshagent-computers==0.38.4; extra == "all"
+Requires-Dist: meshagent-openai==0.38.4; extra == "all"
+Requires-Dist: meshagent-anthropic==0.38.4; extra == "all"
+Requires-Dist: meshagent-codex==0.38.4; extra == "all"
+Requires-Dist: meshagent-otel==0.38.4; extra == "all"
+Requires-Dist: meshagent-mcp==0.38.4; extra == "all"
+Requires-Dist: meshagent-tools==0.38.4; extra == "all"
 Requires-Dist: supabase-auth~=2.28.0; extra == "all"
 Requires-Dist: prompt-toolkit~=3.0.52; extra == "all"
 Provides-Extra: mcp-service
-Requires-Dist: meshagent-agents[all]==0.38.2; extra == "mcp-service"
-Requires-Dist: meshagent-api==0.38.2; extra == "mcp-service"
-Requires-Dist: meshagent-mcp==0.38.2; extra == "mcp-service"
-Requires-Dist: meshagent-tools==0.38.2; extra == "mcp-service"
+Requires-Dist: meshagent-agents[all]==0.38.4; extra == "mcp-service"
+Requires-Dist: meshagent-api==0.38.4; extra == "mcp-service"
+Requires-Dist: meshagent-mcp==0.38.4; extra == "mcp-service"
+Requires-Dist: meshagent-tools==0.38.4; extra == "mcp-service"
 Requires-Dist: supabase-auth~=2.28.0; extra == "mcp-service"
 Dynamic: license-file
 

{meshagent_cli-0.38.2 → meshagent_cli-0.38.4}/meshagent/cli/auth.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from typing import Annotated
 
@@ -69,27 +70,62 @@ def _format_saved_profile(profile: SavedProfileRecord) -> str:
     )
 
 
+def _should_launch_switch_tui(
+    *,
+    profile: str | None,
+    stdin_is_tty: bool,
+    stdout_is_tty: bool,
+) -> bool:
+    return profile is None and stdin_is_tty and stdout_is_tty
+
+
+async def _run_auth_switch_tui(
+    *,
+    saved_profiles: list[SavedProfileRecord],
+):
+    from meshagent.cli.tui.auth_switch import run_auth_switch_tui
+
+    return await run_auth_switch_tui(saved_profiles=saved_profiles)
+
+
 @app.async_command("switch")
 async def switch(
     profile: Annotated[
         str | None,
         typer.Argument(
-            help="Saved profile user id or email. If omitted, saved profiles are listed.",
+            help=(
+                "Saved profile user id or email. If omitted, saved profiles are "
+                "listed or an interactive picker is shown in a TTY."
+            ),
         ),
     ] = None,
 ):
-    if profile is None:
+    selected_profile_selector = profile
+    if selected_profile_selector is None:
         saved_profiles = list_saved_profiles()
         if len(saved_profiles) == 0:
             typer.echo("No saved local profiles.")
             return
 
-        for saved_profile in saved_profiles:
-            typer.echo(_format_saved_profile(saved_profile))
-        return
+        if _should_launch_switch_tui(
+            profile=selected_profile_selector,
+            stdin_is_tty=sys.stdin.isatty(),
+            stdout_is_tty=sys.stdout.isatty(),
+        ):
+            result = await _run_auth_switch_tui(saved_profiles=saved_profiles)
+            if result.status != "completed" or result.selected_profile is None:
+                if result.message is not None:
+                    typer.echo(result.message)
+                return
+
+            selected_profile_selector = result.selected_profile.user_id
+        else:
+            for saved_profile in saved_profiles:
+                typer.echo(_format_saved_profile(saved_profile))
+            return
 
     try:
-        selected_profile = switch_active_profile(profile)
+        selected_profile = switch_active_profile(selected_profile_selector)
     except LookupError as exc:
         typer.echo(str(exc))
         raise typer.Exit(code=1) from exc
@@ -114,3 +150,13 @@ async def whoami():
         await client.close()
 
     typer.echo(_format_user_identity(profile))
+
+
+@app.async_command("token")
+async def token():
+    access_token = await auth_async.get_access_token()
+    if access_token is None:
+        typer.echo("Not logged in", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(access_token)

meshagent_cli-0.38.4/meshagent/cli/auth_test.py

@@ -0,0 +1,309 @@
+from types import SimpleNamespace
+
+import pytest
+
+from meshagent.cli import auth
+from meshagent.cli.local_settings import SavedProfileRecord, StoredUserProfile
+
+
+class _FakeClient:
+    def __init__(self, *, profile: dict[str, object]) -> None:
+        self._profile = profile
+        self.closed = False
+
+    async def get_user_profile(self, user_id: str) -> dict[str, object]:
+        assert user_id == "me"
+        return self._profile
+
+    async def close(self) -> None:
+        self.closed = True
+
+
+class _FakeTTY:
+    def __init__(self, *, is_tty: bool) -> None:
+        self._is_tty = is_tty
+
+    def isatty(self) -> bool:
+        return self._is_tty
+
+
+@pytest.mark.asyncio
+async def test_whoami_uses_user_profile(monkeypatch) -> None:
+    output: list[str] = []
+    client = _FakeClient(
+        profile={
+            "id": "user-123",
+            "first_name": "Jesse",
+            "last_name": "Ezell",
+            "email": "jesse@example.com",
+        }
+    )
+
+    async def _fake_get_access_token() -> str | None:
+        return "oauth-token"
+
+    monkeypatch.setattr(auth.auth_async, "get_access_token", _fake_get_access_token)
+    monkeypatch.setattr(
+        auth,
+        "CustomMeshagentClient",
+        lambda *, base_url, token: client,
+    )
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.whoami()
+
+    assert output == ["Jesse Ezell <jesse@example.com>"]
+    assert client.closed is True
+
+
+@pytest.mark.asyncio
+async def test_whoami_prints_not_logged_in_without_identity(monkeypatch) -> None:
+    output: list[str] = []
+
+    async def _fake_get_access_token() -> str | None:
+        return None
+
+    monkeypatch.setattr(auth.auth_async, "get_access_token", _fake_get_access_token)
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.whoami()
+
+    assert output == ["Not logged in"]
+
+
+@pytest.mark.asyncio
+async def test_token_prints_access_token(monkeypatch) -> None:
+    output: list[str] = []
+
+    async def _fake_get_access_token() -> str | None:
+        return "oauth-token"
+
+    monkeypatch.setattr(auth.auth_async, "get_access_token", _fake_get_access_token)
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.token()
+
+    assert output == ["oauth-token"]
+
+
+@pytest.mark.asyncio
+async def test_token_exits_when_not_logged_in(monkeypatch) -> None:
+    output: list[tuple[str, bool]] = []
+
+    async def _fake_get_access_token() -> str | None:
+        return None
+
+    def _fake_echo(message: str, *, err: bool = False) -> None:
+        output.append((message, err))
+
+    monkeypatch.setattr(auth.auth_async, "get_access_token", _fake_get_access_token)
+    monkeypatch.setattr(auth.typer, "echo", _fake_echo)
+
+    with pytest.raises(auth.typer.Exit) as exc_info:
+        await auth.token()
+
+    assert exc_info.value.exit_code == 1
+    assert output == [("Not logged in", True)]
+
+
+@pytest.mark.asyncio
+async def test_login_passes_api_url_to_auth_async(monkeypatch) -> None:
+    captured: dict[str, str | None] = {}
+
+    async def _fake_login(*, api_url: str | None = None) -> None:
+        captured["api_url"] = api_url
+
+    async def _fake_get_active_project() -> str | None:
+        return "project-123"
+
+    monkeypatch.setattr(auth.auth_async, "login", _fake_login)
+    monkeypatch.setattr(auth, "get_active_project", _fake_get_active_project)
+
+    await auth.login(api_url="https://override.meshagent.test")
+
+    assert captured == {"api_url": "https://override.meshagent.test"}
+
+
+@pytest.mark.asyncio
+async def test_switch_lists_saved_profiles(monkeypatch) -> None:
+    output: list[str] = []
+
+    monkeypatch.setattr(
+        auth,
+        "list_saved_profiles",
+        lambda: [
+            SavedProfileRecord(
+                user_id="user-123",
+                profile=StoredUserProfile(
+                    id="user-123",
+                    first_name="Jesse",
+                    last_name="Ezell",
+                    email="jesse@example.com",
+                ),
+                api_url="https://api.meshagent.test",
+                is_active=True,
+            )
+        ],
+    )
+    monkeypatch.setattr(auth.sys, "stdin", _FakeTTY(is_tty=False))
+    monkeypatch.setattr(auth.sys, "stdout", _FakeTTY(is_tty=False))
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.switch()
+
+    assert output == [
+        "* Jesse Ezell [user-123] @ https://api.meshagent.test",
+    ]
+
+
+def test_should_launch_switch_tui_only_when_selector_missing_in_tty() -> None:
+    assert (
+        auth._should_launch_switch_tui(
+            profile=None,
+            stdin_is_tty=True,
+            stdout_is_tty=True,
+        )
+        is True
+    )
+    assert (
+        auth._should_launch_switch_tui(
+            profile="user-123",
+            stdin_is_tty=True,
+            stdout_is_tty=True,
+        )
+        is False
+    )
+    assert (
+        auth._should_launch_switch_tui(
+            profile=None,
+            stdin_is_tty=False,
+            stdout_is_tty=True,
+        )
+        is False
+    )
+
+
+@pytest.mark.asyncio
+async def test_switch_launches_tui_when_no_selector_in_tty(monkeypatch) -> None:
+    output: list[str] = []
+    saved_profiles = [
+        SavedProfileRecord(
+            user_id="user-123",
+            profile=StoredUserProfile(
+                id="user-123",
+                first_name="Jesse",
+                last_name="Ezell",
+                email="jesse@example.com",
+            ),
+            api_url="https://api.meshagent.test",
+            is_active=True,
+        ),
+        SavedProfileRecord(
+            user_id="user-456",
+            profile=StoredUserProfile(
+                id="user-456",
+                first_name="Taylor",
+                last_name="Swift",
+                email="taylor@example.com",
+            ),
+            api_url="https://api.meshagent.test",
+            is_active=False,
+        ),
+    ]
+    selected_selectors: list[str] = []
+
+    async def _fake_run_auth_switch_tui(*, saved_profiles):
+        return SimpleNamespace(
+            status="completed",
+            message=None,
+            selected_profile=saved_profiles[1],
+        )
+
+    monkeypatch.setattr(auth, "list_saved_profiles", lambda: saved_profiles)
+    monkeypatch.setattr(auth.sys, "stdin", _FakeTTY(is_tty=True))
+    monkeypatch.setattr(auth.sys, "stdout", _FakeTTY(is_tty=True))
+    monkeypatch.setattr(
+        auth,
+        "_run_auth_switch_tui",
+        _fake_run_auth_switch_tui,
+    )
+    monkeypatch.setattr(
+        auth,
+        "switch_active_profile",
+        lambda selector: (
+            selected_selectors.append(selector)
+            or SavedProfileRecord(
+                user_id="user-456",
+                profile=StoredUserProfile(
+                    id="user-456",
+                    first_name="Taylor",
+                    last_name="Swift",
+                    email="taylor@example.com",
+                ),
+                api_url="https://api.meshagent.test",
+                is_active=True,
+            )
+        ),
+    )
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.switch()
+
+    assert selected_selectors == ["user-456"]
+    assert output == [
+        "Active profile: * Taylor Swift [user-456] @ https://api.meshagent.test",
+    ]
+
+
+@pytest.mark.asyncio
+async def test_switch_prints_cancel_message_when_tui_is_canceled(monkeypatch) -> None:
+    output: list[str] = []
+    switch_attempted = False
+
+    monkeypatch.setattr(
+        auth,
+        "list_saved_profiles",
+        lambda: [
+            SavedProfileRecord(
+                user_id="user-123",
+                profile=StoredUserProfile(
+                    id="user-123",
+                    first_name="Jesse",
+                    last_name="Ezell",
+                    email="jesse@example.com",
+                ),
+                api_url="https://api.meshagent.test",
+                is_active=True,
+            )
+        ],
+    )
+    monkeypatch.setattr(auth.sys, "stdin", _FakeTTY(is_tty=True))
+    monkeypatch.setattr(auth.sys, "stdout", _FakeTTY(is_tty=True))
+
+    async def _fake_run_auth_switch_tui(*, saved_profiles):
+        del saved_profiles
+        return SimpleNamespace(
+            status="canceled",
+            message="Profile switch canceled.",
+            selected_profile=None,
+        )
+
+    monkeypatch.setattr(
+        auth,
+        "_run_auth_switch_tui",
+        _fake_run_auth_switch_tui,
+    )
+
+    def _unexpected_switch(selector: str):
+        del selector
+        nonlocal switch_attempted
+        switch_attempted = True
+        raise AssertionError("switch_active_profile should not be called")
+
+    monkeypatch.setattr(auth, "switch_active_profile", _unexpected_switch)
+    monkeypatch.setattr(auth.typer, "echo", output.append)
+
+    await auth.switch()
+
+    assert switch_attempted is False
+    assert output == ["Profile switch canceled."]

{meshagent_cli-0.38.2 → meshagent_cli-0.38.4}/meshagent/cli/cli.py

@@ -97,6 +97,12 @@ app.add_lazy_command(
     help="Send a one-shot prompt through the LLM router",
     attribute="ask_command",
 )
+app.add_lazy_command(
+    name="launch",
+    module="meshagent.cli.launch",
+    attribute="launch_group",
+    help="Launch CLI apps through MeshAgent",
+)
 app.add_lazy_command(
     name="token",
     module="meshagent.cli.participant_token",

{meshagent_cli-0.38.2 → meshagent_cli-0.38.4}/meshagent/cli/cli_test.py

@@ -43,6 +43,7 @@ def test_root_help_hides_legacy_command_namespaces() -> None:
     assert result.exit_code == 0
     assert "│ build" in result.output
     assert "│ deploy" in result.output
+    assert "│ launch" in result.output
     assert "│ room" in result.output
     assert "│ call" not in result.output
     assert "│ package" not in result.output

{meshagent_cli-0.38.2 → meshagent_cli-0.38.4}/meshagent/cli/containers.py

@@ -7,6 +7,7 @@ import os
 import re
 import tarfile
 import time
+from datetime import datetime
 from pathlib import Path
 
 import pathlib
@@ -16,6 +17,8 @@ import aiofiles
 import aiofiles.ospath
 import typer
 from rich import print
+from rich.console import Console
+from rich.table import Table
 from typing import Annotated, Optional, List, Dict
 
 from meshagent.cli import async_typer
@@ -33,6 +36,7 @@ from meshagent.api import (
 )
 from meshagent.api.room_server_client import (
     DockerSecret,
+    ImageDescriptor,
 )
 from meshagent.api.specs.service import (
     ContainerMountSpec,
@@ -163,6 +167,52 @@ def _parse_image_operation_mounts(
     return mount_spec
 
 
+def _format_image_timestamp(value: datetime | None) -> str:
+    if value is None:
+        return "—"
+    return value.astimezone().strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def _format_image_bytes(value: int | None) -> str:
+    if value is None:
+        return "—"
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = float(value)
+    unit_index = 0
+    while size >= 1024 and unit_index < len(units) - 1:
+        size /= 1024
+        unit_index += 1
+    if unit_index == 0:
+        return f"{int(size)} {units[unit_index]}"
+    return f"{size:.1f} {units[unit_index]}"
+
+
+def _image_reference(image) -> str:
+    if image.preferred_ref:
+        return image.preferred_ref
+    if len(image.references) > 0:
+        return image.references[0]
+    return image.id
+
+
+def _descriptor_table(*, title: str, descriptor: ImageDescriptor | None) -> Table:
+    table = Table(title=title, show_header=True, header_style="bold magenta")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+    if descriptor is None:
+        table.add_row("descriptor", "—")
+        return table
+    table.add_row("digest", descriptor.digest)
+    table.add_row("media_type", descriptor.media_type or "—")
+    table.add_row("size", _format_image_bytes(descriptor.size))
+    if len(descriptor.annotations) == 0:
+        table.add_row("annotations", "—")
+    else:
+        for key, value in descriptor.annotations.items():
+            table.add_row(f"annotation:{key}", value)
+    return table
+
+
 async def _stream_container_job_logs_and_wait_for_exit(
     *,
     client: RoomClient,
@@ -774,6 +824,10 @@ async def images_list(
     *,
     project_id: ProjectIdOption,
     room: RoomOption,
+    output: Annotated[
+        str,
+        typer.Option(help="table | json"),
+    ] = "table",
 ):
     account_client, client = await _with_client(
         project_id=project_id,
@@ -781,7 +835,144 @@ async def images_list(
     )
     try:
         imgs = await client.containers.list_images()
-        print([i.model_dump() for i in imgs])
+        if output == "json":
+            print([i.model_dump(mode="json") for i in imgs])
+            return
+
+        table = Table(title="Images")
+        table.add_column("Reference", style="cyan")
+        table.add_column("ID")
+        table.add_column("Updated")
+        table.add_column("Created")
+        table.add_column("Media Type")
+        for image in imgs:
+            table.add_row(
+                _image_reference(image),
+                image.id,
+                _format_image_timestamp(image.updated_at),
+                _format_image_timestamp(image.created_at),
+                image.target_media_type or "—",
+            )
+        Console().print(table)
+    finally:
+        await client.__aexit__(None, None, None)
+        await account_client.close()
+
+
+@images_app.async_command(
+    "inspect",
+    help="Inspect a container image in a room by image ID.",
+)
+async def images_inspect(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    image_id: Annotated[
+        str,
+        typer.Option(..., "--image-id", help="Image ID from `meshagent images list`"),
+    ],
+):
+    account_client, client = await _with_client(
+        project_id=project_id,
+        room=room,
+    )
+    try:
+        inspection = await client.containers.inspect_image(image_id=image_id)
+        console = Console()
+
+        summary_table = Table(
+            title="Image", show_header=True, header_style="bold magenta"
+        )
+        summary_table.add_column("Field", style="cyan")
+        summary_table.add_column("Value")
+        summary_table.add_row("reference", _image_reference(inspection.image))
+        summary_table.add_row("id", inspection.image.id)
+        summary_table.add_row(
+            "references",
+            ", ".join(inspection.image.references)
+            if inspection.image.references
+            else "—",
+        )
+        summary_table.add_row(
+            "created_at",
+            _format_image_timestamp(inspection.image.created_at),
+        )
+        summary_table.add_row(
+            "updated_at",
+            _format_image_timestamp(inspection.image.updated_at),
+        )
+        summary_table.add_row(
+            "target_media_type",
+            inspection.image.target_media_type or "—",
+        )
+        summary_table.add_row(
+            "content_size",
+            _format_image_bytes(inspection.content_size),
+        )
+        if len(inspection.image.labels) == 0:
+            summary_table.add_row("labels", "—")
+        else:
+            for key, value in inspection.image.labels.items():
+                summary_table.add_row(f"label:{key}", value)
+
+        manifests_table = Table(
+            title="Manifests",
+            show_header=True,
+            header_style="bold magenta",
+        )
+        manifests_table.add_column("Digest", style="cyan")
+        manifests_table.add_column("Media Type")
+        manifests_table.add_column("Size")
+        manifests_table.add_column("Platform")
+        if len(inspection.manifests) == 0:
+            manifests_table.add_row("—", "—", "—", "—")
+        else:
+            for manifest in inspection.manifests:
+                platform = "/".join(
+                    part
+                    for part in (
+                        manifest.platform_os,
+                        manifest.platform_architecture,
+                        manifest.platform_variant,
+                    )
+                    if part
+                )
+                manifests_table.add_row(
+                    manifest.descriptor.digest,
+                    manifest.descriptor.media_type or "—",
+                    _format_image_bytes(manifest.descriptor.size),
+                    platform or "—",
+                )
+
+        layers_table = Table(
+            title="Layers",
+            show_header=True,
+            header_style="bold magenta",
+        )
+        layers_table.add_column("Digest", style="cyan")
+        layers_table.add_column("Media Type")
+        layers_table.add_column("Size")
+        if len(inspection.layers) == 0:
+            layers_table.add_row("—", "—", "—")
+        else:
+            for layer in inspection.layers:
+                layers_table.add_row(
+                    layer.digest,
+                    layer.media_type or "—",
+                    _format_image_bytes(layer.size),
+                )
+
+        console.print(summary_table)
+        console.print(_descriptor_table(title="Target", descriptor=inspection.target))
+        console.print(
+            _descriptor_table(
+                title="Selected Manifest",
+                descriptor=inspection.selected_manifest,
+            )
+        )
+        console.print(_descriptor_table(title="Config", descriptor=inspection.config))
+        console.print(manifests_table)
+        console.print(layers_table)
     finally:
         await client.__aexit__(None, None, None)
         await account_client.close()