meshagent-cli 0.6.1__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()