meshagent-cli 0.5.18__py3-none-any.whl → 0.6.0__py3-none-any.whl

meshagent/cli/participant_token.py

@@ -1,12 +1,14 @@
 import typer
 from rich import print
 from typing import Annotated
-from meshagent.cli.common_options import ProjectIdOption, ApiKeyIdOption, RoomOption
 from meshagent.api import ParticipantToken
-from meshagent.cli.helper import resolve_project_id, resolve_api_key, resolve_room
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client
+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()
 
@@ -15,35 +17,44 @@ app = async_typer.AsyncTyper()
 async def generate(
     *,
     project_id: ProjectIdOption = None,
-    token_path: Annotated[str, typer.Option()],
-    room: RoomOption,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option()],
-    role: str = "agent",
+    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:
-        project_id = await resolve_project_id(project_id=project_id)
-        api_key_id = await resolve_api_key(project_id=project_id, api_key_id=api_key_id)
-        room = resolve_room(room)
-        key = (
-            await client.decrypt_project_api_key(project_id=project_id, id=api_key_id)
-        )["token"]
+        with open(str(pathlib.Path(input).expanduser().resolve()), "rb") as f:
+            spec = parse_yaml_raw_as(ParticipantTokenSpec, f.read())
 
         token = ParticipantToken(
-            name=name, project_id=project_id, api_key_id=api_key_id
+            name=spec.identity,
         )
 
-        token.add_role_grant(role=role)
+        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_room_grant(room)
+        token.add_api_grant(spec.api)
 
-        if token_path is None:
-            print(token.to_jwt(token=key))
+        if output is None:
+            print(token.to_jwt(api_key=key))
 
         else:
-            pathlib.Path(token_path).expanduser().resolve().write_text(
-                token.to_jwt(token=key)
+            pathlib.Path(output).expanduser().resolve().write_text(
+                token.to_jwt(api_key=key)
             )
 
     finally:

meshagent/cli/queue.py

@@ -1,17 +1,16 @@
 import typer
 from rich import print
 from typing import Annotated, Optional
-from meshagent.cli.common_options import ProjectIdOption, ApiKeyIdOption, RoomOption
+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,
-    ParticipantToken,
     WebSocketClientProtocol,
     RoomException,
 )
-from meshagent.cli.helper import resolve_project_id, resolve_api_key, resolve_room
+from meshagent.cli.helper import resolve_project_id, resolve_room
 from meshagent.cli import async_typer
 from meshagent.cli.helper import get_client
 
@@ -23,9 +22,6 @@ async def send(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user",
     queue: Annotated[str, typer.Option(..., help="Queue name")],
     json: Optional[str] = typer.Option(..., help="a JSON message to send to the queue"),
     file: Annotated[
@@ -36,27 +32,15 @@ async def send(
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
-        api_key_id = await resolve_api_key(project_id, api_key_id)
         room = resolve_room(room)
 
-        key = (
-            await account_client.decrypt_project_api_key(
-                project_id=project_id, id=api_key_id
-            )
-        )["token"]
-
-        token = ParticipantToken(
-            name=name, project_id=project_id, api_key_id=api_key_id
-        )
-
-        token.add_role_grant(role=role)
-        token.add_room_grant(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=token.to_jwt(token=key),
+                token=connection.jwt,
             )
         ) as client:
             if file is not None:
@@ -78,34 +62,19 @@ async def receive(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user",
     queue: Annotated[str, typer.Option(..., help="Queue name")],
 ):
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
-        api_key_id = await resolve_api_key(project_id, api_key_id)
         room = resolve_room(room)
 
-        key = (
-            await account_client.decrypt_project_api_key(
-                project_id=project_id, id=api_key_id
-            )
-        )["token"]
-
-        token = ParticipantToken(
-            name=name, project_id=project_id, api_key_id=api_key_id
-        )
-
-        token.add_role_grant(role=role)
-        token.add_room_grant(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=token.to_jwt(token=key),
+                token=connection.jwt,
             )
         ) as client:
             response = await client.queues.receive(name=queue, wait=False)