meshagent-cli 0.7.0__py3-none-any.whl

meshagent/cli/oauth2.py

@@ -0,0 +1,189 @@
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+)
+from meshagent.api.oauth import OAuthClientConfig
+from meshagent.api import RoomClient, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from rich import print
+from typing import Annotated, Optional
+import typer
+import json
+
+app = async_typer.AsyncTyper(help="OAuth2 test commands")
+
+
+@app.async_command("request")
+async def oauth2(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    from_participant_id: Annotated[str, typer.Option()],
+    client_id: Annotated[str, typer.Option()],
+    authorization_endpoint: Annotated[str, typer.Option()],
+    token_endpoint: Annotated[str, typer.Option()],
+    scopes: Annotated[Optional[str], typer.Option()] = None,
+    client_secret: Annotated[Optional[str], typer.Option()],
+    redirect_uri: Annotated[Optional[str], typer.Option()],
+    pkce: Annotated[bool, typer.Option()] = True,
+):
+    """
+    Run an OAuth2 request test between two participants in the same room.
+    One will act as the consumer, the other as the provider.
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = await account_client.connect_room(
+            project_id=project_id, room=room
+        )
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            print("[green]Requesting OAuth token from consumer side...[/green]")
+            token = await consumer.secrets.request_oauth_token(
+                oauth=OAuthClientConfig(
+                    client_id=client_id,
+                    authorization_endpoint=authorization_endpoint,
+                    token_endpoint=token_endpoint,
+                    scopes=scopes.split(",") if scopes is not None else scopes,
+                    client_secret=client_secret,
+                    no_pkce=not pkce,
+                ),
+                from_participant_id=from_participant_id,
+                timeout=300,
+                redirect_uri=redirect_uri,
+            )
+
+            print(f"[bold cyan]Got access token:[/bold cyan] {token}")
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("get")
+async def get(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    delegated_to: Annotated[str, typer.Option()],
+    client_id: Annotated[str, typer.Option()],
+    authorization_endpoint: Annotated[str, typer.Option()],
+    token_endpoint: Annotated[str, typer.Option()],
+    scopes: Annotated[Optional[str], typer.Option()] = None,
+    client_secret: Annotated[Optional[str], typer.Option()],
+    redirect_uri: Annotated[Optional[str], typer.Option()],
+    pkce: Annotated[bool, typer.Option()] = True,
+):
+    """
+    Run an OAuth2 request test between two participants in the same room.
+    One will act as the consumer, the other as the provider.
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = await account_client.connect_room(
+            project_id=project_id, room=room
+        )
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            print("[green]Requesting OAuth token from consumer side...[/green]")
+            token = await consumer.secrets.get_offline_oauth_token(
+                oauth=OAuthClientConfig(
+                    client_id=client_id,
+                    authorization_endpoint=authorization_endpoint,
+                    token_endpoint=token_endpoint,
+                    scopes=scopes.split(",") if scopes is not None else scopes,
+                    client_secret=client_secret,
+                    no_pkce=not pkce,
+                ),
+                delegated_to=delegated_to,
+            )
+
+            print(f"[bold cyan]Got access token:[/bold cyan] {token}")
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list")
+async def list(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+):
+    """
+    list secrets
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = await account_client.connect_room(
+            project_id=project_id, room=room
+        )
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            secrets = await consumer.secrets.list_user_secrets()
+            output = []
+            for s in secrets:
+                output.append(s.model_dump(mode="json"))
+
+            print(json.dumps(output, indent=2))
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("delete")
+async def delete(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    id: str,
+    delegated_to: Annotated[Optional[str], typer.Option()] = None,
+):
+    """
+    delete a secret
+    """
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        jwt_consumer = await account_client.connect_room(
+            project_id=project_id, room=room
+        )
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            await consumer.secrets.delete_user_secret(id=id, delegated_to=delegated_to)
+            print("deleted secret")
+
+    finally:
+        await account_client.close()

meshagent/cli/participant_token.py

@@ -0,0 +1,61 @@
+import typer
+from rich import print
+from typing import Annotated
+from meshagent.api import ParticipantToken
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, resolve_key, resolve_project_id
+import pathlib
+from typing import Optional
+from meshagent.api.participant_token import ParticipantTokenSpec
+from pydantic_yaml import parse_yaml_raw_as
+from meshagent.cli.common_options import ProjectIdOption
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("generate")
+async def generate(
+    *,
+    project_id: ProjectIdOption = None,
+    output: Annotated[
+        Optional[str],
+        typer.Option("--output", "-o", help="File path to a file"),
+    ] = None,
+    input: Annotated[
+        str,
+        typer.Option("--input", "-i", help="File path to a token spec"),
+    ],
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
+):
+    project_id = await resolve_project_id(project_id=project_id)
+    key = await resolve_key(project_id=project_id, key=key)
+
+    client = await get_client()
+    try:
+        with open(str(pathlib.Path(input).expanduser().resolve()), "rb") as f:
+            spec = parse_yaml_raw_as(ParticipantTokenSpec, f.read())
+
+        token = ParticipantToken(
+            name=spec.identity,
+        )
+
+        if spec.role is not None:
+            token.add_role_grant(role=spec.role)
+        if spec.room is not None:
+            token.add_room_grant(spec.room)
+
+        token.add_api_grant(spec.api)
+
+        if output is None:
+            print(token.to_jwt(api_key=key))
+
+        else:
+            pathlib.Path(output).expanduser().resolve().write_text(
+                token.to_jwt(api_key=key)
+            )
+
+    finally:
+        await client.close()

meshagent/cli/projects.py

@@ -0,0 +1,105 @@
+import typer
+from rich import print
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    print_json_table,
+    set_active_project,
+    get_active_project,
+)
+from meshagent.cli.common_options import OutputFormatOption
+
+app = async_typer.AsyncTyper(help="Manage or activate your meshagent projects")
+
+
+@app.async_command("create")
+async def create(name: str):
+    client = await get_client()
+    try:
+        result = await client.create_project(name)
+        print(f"[green]Project created:[/] {result['id']}")
+    finally:
+        await client.close()
+
+
+@app.async_command("list")
+async def list(
+    o: OutputFormatOption = "table",
+):
+    client = await get_client()
+    projects = await client.list_projects()
+    active_project = await get_active_project()
+    for project in projects["projects"]:
+        if project["id"] == active_project:
+            project["name"] = "*" + project["name"]
+
+    if o == "json":
+        print(projects)
+    else:
+        print_json_table(projects["projects"], "id", "name")
+    await client.close()
+
+
+@app.async_command("activate")
+async def activate(
+    project_id: str | None = typer.Argument(None),
+    interactive: bool = typer.Option(
+        False,
+        "-i",
+        "--interactive",
+        help="Interactively select or create a project",
+    ),
+):
+    client = await get_client()
+    try:
+        if interactive:
+            response = await client.list_projects()
+            projects = response["projects"]
+
+            if not projects:
+                if typer.confirm(
+                    "There are no projects. Would you like to create one?",
+                    default=True,
+                ):
+                    name = typer.prompt("Project name")
+                    created = await client.create_project(name)
+                    project_id = created["id"]
+                else:
+                    raise typer.Exit(code=0)
+            else:
+                for idx, proj in enumerate(projects, start=1):
+                    print(f"[{idx}] {proj['name']} ({proj['id']})")
+                new_project_index = len(projects) + 1
+                print(f"[{new_project_index}] Create a new project")
+                exit_index = new_project_index + 1
+                print(f"[{exit_index}] Exit")
+
+                choice = typer.prompt("Select a project", type=int)
+                if choice == exit_index:
+                    return
+                elif choice == new_project_index:
+                    name = typer.prompt("Project name")
+                    # TODO: validate name
+                    created = await client.create_project(name)
+                    project_id = created["id"]
+                elif 1 <= choice <= len(projects):
+                    project_id = projects[choice - 1]["id"]
+                else:
+                    print("[red]Invalid selection[/red]")
+                    raise typer.Exit(code=1)
+
+        if project_id is None and not interactive:
+            print("[red]project_id required[/red]")
+            raise typer.Exit(code=1)
+
+        if project_id is not None:
+            projects = (await client.list_projects())["projects"]
+            for project in projects:
+                if project["id"] == project_id:
+                    await set_active_project(project_id=project_id)
+                    return project_id
+
+            print(f"[red]Invalid project id: {project_id}[/red]")
+            raise typer.Exit(code=1)
+    finally:
+        await client.close()

meshagent/cli/queue.py

@@ -0,0 +1,91 @@
+import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+import json as _json
+
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.api import (
+    RoomClient,
+    WebSocketClientProtocol,
+    RoomException,
+)
+from meshagent.cli.helper import resolve_project_id, resolve_room
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client
+
+app = async_typer.AsyncTyper(help="Use queues in a room")
+
+
+@app.async_command("send")
+async def send(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    queue: Annotated[str, typer.Option(..., help="Queue name")],
+    json: Optional[str] = typer.Option(..., help="a JSON message to send to the queue"),
+    file: Annotated[
+        Optional[str],
+        typer.Option("--file", "-f", help="File path to a JSON file"),
+    ] = None,
+):
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        connection = await account_client.connect_room(project_id=project_id, room=room)
+
+        print("[bold green]Connecting to room...[/bold green]")
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=connection.jwt,
+            )
+        ) as client:
+            if file is not None:
+                with open(file, "rb") as f:
+                    message = f.read()
+            else:
+                message = _json.loads(json)
+
+            await client.queues.send(name=queue, message=message)
+
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()
+
+
+@app.async_command("receive")
+async def receive(
+    *,
+    project_id: ProjectIdOption = None,
+    room: RoomOption,
+    queue: Annotated[str, typer.Option(..., help="Queue name")],
+):
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        connection = await account_client.connect_room(project_id=project_id, room=room)
+
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=connection.jwt,
+            )
+        ) as client:
+            response = await client.queues.receive(name=queue, wait=False)
+            if response is None:
+                print("[bold yellow]Queue did not contain any messages.[/bold yellow]")
+                raise typer.Exit(1)
+            else:
+                print(response)
+
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()

meshagent/cli/room.py

@@ -0,0 +1,214 @@
+# rooms_cli.py (add to the same module or import into your CLI package)
+
+import typer
+from rich import print
+from typing import Annotated, Optional
+import json
+
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+)
+from meshagent.api import RoomException
+
+app = async_typer.AsyncTyper()
+
+# ---------------------------
+# Helpers
+# ---------------------------
+
+
+async def _resolve_room_id_or_fail(
+    account_client, *, project_id: str, room_id: Optional[str], room_name: Optional[str]
+) -> str:
+    """
+    If room_id is provided, return it.
+    Else, resolve via room_name -> account_client.get_room(...).id
+    """
+    if room_id:
+        return room_id
+    if not room_name:
+        raise RoomException("You must provide either --id or --name.")
+    room = await account_client.get_room(project_id=project_id, name=room_name)
+    return room.id
+
+
+def _maybe_parse_json(label: str, s: Optional[str]):
+    if s is None:
+        return None
+    try:
+        return json.loads(s)
+    except json.JSONDecodeError as e:
+        raise RoomException(f"Invalid {label} JSON: {e}") from e
+
+
+# ---------------------------
+# Commands
+# ---------------------------
+
+
+@app.async_command("create")
+async def room_create_command(
+    *,
+    project_id: ProjectIdOption = None,
+    name: Annotated[str, typer.Option(..., help="Room name")],
+    if_not_exists: Annotated[
+        bool, typer.Option(help="Do not error if the room already exists")
+    ] = False,
+    metadata: Annotated[
+        Optional[str], typer.Option(help="Optional JSON object for room metadata")
+    ] = None,
+):
+    """
+    Create a room in the project.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        meta_obj = _maybe_parse_json("metadata", metadata)
+
+        print(f"[bold green]Creating room {name}[/bold green]")
+        room = await account_client.create_room(
+            project_id=project_id,
+            name=name,
+            if_not_exists=if_not_exists,
+            metadata=meta_obj,
+        )
+
+        print(
+            json.dumps(
+                {"id": room.id, "name": room.name, "metadata": room.metadata}, indent=2
+            )
+        )
+
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("delete")
+async def room_delete_command(
+    *,
+    project_id: ProjectIdOption = None,
+    id: Annotated[Optional[str], typer.Option(help="Room ID (preferred)")] = None,
+    name: Optional[str] = None,
+):
+    """
+    Delete a room by ID (or by name if --name is supplied).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name) if name else None
+        rid = await _resolve_room_id_or_fail(
+            account_client, project_id=project_id, room_id=id, room_name=room_name
+        )
+
+        print(f"[bold yellow]Deleting room id={rid}...[/bold yellow]")
+        await account_client.delete_room(project_id=project_id, room_id=rid)
+        print("[bold cyan]Room deleted.[/bold cyan]")
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("update")
+async def room_update_command(
+    *,
+    project_id: ProjectIdOption = None,
+    id: Annotated[Optional[str], typer.Option(help="Room ID (preferred)")] = None,
+    name: Optional[str] = None,
+    new_name: Annotated[str, typer.Option(..., help="New room name")],
+):
+    """
+    Update a room's name (ID is preferred; name will be resolved to ID if needed).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name) if name else None
+        rid = await _resolve_room_id_or_fail(
+            account_client, project_id=project_id, room_id=id, room_name=room_name
+        )
+
+        print(
+            f"[bold green]Updating room id={rid} -> name='{new_name}'...[/bold green]"
+        )
+        await account_client.update_room(
+            project_id=project_id, room_id=rid, name=new_name
+        )
+        print("[bold cyan]Room updated.[/bold cyan]")
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list")
+async def room_list_command(
+    *,
+    project_id: ProjectIdOption = None,
+    limit: Annotated[
+        int, typer.Option(help="Max rooms to return", min=1, max=500)
+    ] = 50,
+    offset: Annotated[int, typer.Option(help="Offset for pagination", min=0)] = 0,
+    order_by: Annotated[
+        str, typer.Option(help='Order by column (e.g. "room_name", "created_at")')
+    ] = "room_name",
+):
+    """
+    List rooms in the project.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        print("[bold green]Fetching rooms...[/bold green]")
+
+        rooms = await account_client.list_rooms(
+            project_id=project_id,
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+        )
+        output = [{"id": r.id, "name": r.name, "metadata": r.metadata} for r in rooms]
+        print(json.dumps(output, indent=2))
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("get")
+async def room_get_command(
+    *,
+    project_id: ProjectIdOption = None,
+    name: Optional[str] = None,
+):
+    """
+    Get a single room by name (handy for resolving the ID).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name)
+
+        print(f"[bold green]Fetching room '{room_name}'...[/bold green]")
+        r = await account_client.get_room(project_id=project_id, name=room_name)
+        print(
+            json.dumps({"id": r.id, "name": r.name, "metadata": r.metadata}, indent=2)
+        )
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()