meshagent-cli 0.7.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

meshagent/cli/mailboxes.py

@@ -0,0 +1,223 @@
+# meshagent/cli/mailboxes.py
+
+from __future__ import annotations
+
+from typing import Annotated, Optional
+
+import typer
+from aiohttp import ClientResponseError
+from rich import print
+
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption, OutputFormatOption
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
+
+app = async_typer.AsyncTyper(help="Manage mailboxes for your project")
+
+
+@app.async_command("create")
+async def mailbox_create(
+    *,
+    project_id: ProjectIdOption,
+    address: Annotated[
+        str,
+        typer.Option(
+            "--address",
+            "-a",
+            help="Mailbox email address (unique per project)",
+        ),
+    ],
+    room: Annotated[
+        str,
+        typer.Option(
+            "--room",
+            "-r",
+            help="Room name to route inbound mail into",
+        ),
+    ],
+    queue: Annotated[
+        str,
+        typer.Option(
+            "--queue",
+            "-q",
+            help="Queue name to deliver inbound messages to",
+        ),
+    ],
+    public: Annotated[
+        bool,
+        typer.Option(
+            "--public",
+            help="Queue name to deliver inbound messages to",
+        ),
+    ] = False,
+):
+    """Create a mailbox attached to the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        try:
+            await client.create_mailbox(
+                project_id=project_id,
+                address=address,
+                room=room,
+                queue=queue,
+                public=public,
+            )
+        except ClientResponseError as exc:
+            # Common patterns: 409 conflict on duplicate address, 400 validation, etc.
+            if exc.status == 409:
+                print(f"[red]Mailbox address already in use:[/] {address}")
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Created mailbox:[/] {address}")
+    finally:
+        await client.close()
+
+
+@app.async_command("update")
+async def mailbox_update(
+    *,
+    project_id: ProjectIdOption,
+    address: Annotated[
+        str,
+        typer.Argument(help="Mailbox email address to update"),
+    ],
+    room: Annotated[
+        Optional[str],
+        typer.Option(
+            "--room",
+            "-r",
+            help="Room name to route inbound mail into",
+        ),
+    ] = None,
+    queue: Annotated[
+        Optional[str],
+        typer.Option(
+            "--queue",
+            "-q",
+            help="Queue name to deliver inbound messages to",
+        ),
+    ] = None,
+    public: Annotated[
+        bool,
+        typer.Option(
+            "--public",
+            help="Queue name to deliver inbound messages to",
+        ),
+    ] = False,
+):
+    """Update a mailbox routing configuration."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        # Keep parity with other CLIs: allow partial update by reading existing first
+        if room is None or queue is None:
+            try:
+                mb = await client.get_mailbox(project_id=project_id, address=address)
+            except ClientResponseError as exc:
+                if exc.status == 404:
+                    print(f"[red]Mailbox not found:[/] {address}")
+                    raise typer.Exit(code=1)
+                raise
+            room = room or mb.room
+            queue = queue or mb.queue
+
+        try:
+            await client.update_mailbox(
+                project_id=project_id,
+                address=address,
+                room=room,
+                queue=queue,
+                public=public,
+            )
+        except ClientResponseError as exc:
+            if exc.status == 404:
+                print(f"[red]Mailbox not found:[/] {address}")
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Updated mailbox:[/] {address}")
+    finally:
+        await client.close()
+
+
+@app.async_command("show")
+async def mailbox_show(
+    *,
+    project_id: ProjectIdOption,
+    address: Annotated[str, typer.Argument(help="Mailbox address to show")],
+):
+    """Show mailbox details."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        try:
+            mb = await client.get_mailbox(project_id=project_id, address=address)
+        except ClientResponseError as exc:
+            if exc.status == 404:
+                print(f"[red]Mailbox not found:[/] {address}")
+                raise typer.Exit(code=1)
+            raise
+        print(mb.model_dump(mode="json"))
+    finally:
+        await client.close()
+
+
+@app.async_command("list")
+async def mailbox_list(
+    *,
+    project_id: ProjectIdOption,
+    o: OutputFormatOption = "table",
+):
+    """List mailboxes for the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        mailboxes = await client.list_mailboxes(project_id=project_id)
+
+        if o == "json":
+            # Keep your existing conventions: wrap in an object.
+            print({"mailboxes": [mb.model_dump(mode="json") for mb in mailboxes]})
+        else:
+            print_json_table(
+                [
+                    {
+                        "address": mb.address,
+                        "room": mb.room,
+                        "queue": mb.queue,
+                        "public": mb.public,
+                    }
+                    for mb in mailboxes
+                ],
+                "address",
+                "room",
+                "queue",
+            )
+    finally:
+        await client.close()
+
+
+@app.async_command("delete")
+async def mailbox_delete(
+    *,
+    project_id: ProjectIdOption,
+    address: Annotated[str, typer.Argument(help="Mailbox address to delete")],
+):
+    """Delete a mailbox."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        try:
+            await client.delete_mailbox(project_id=project_id, address=address)
+        except ClientResponseError as exc:
+            if exc.status == 404:
+                print(f"[red]Mailbox not found:[/] {address}")
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Mailbox deleted:[/] {address}")
+    finally:
+        await client.close()

meshagent/cli/meeting_transcriber.py

@@ -12,7 +12,7 @@ from meshagent.cli.helper import (
     resolve_room,
     resolve_key,
 )
-
+import os
 from meshagent.api import RequiredSchema
 from meshagent.api.services import ServiceHost
 
@@ -22,9 +22,11 @@ app = async_typer.AsyncTyper(help="Join a meeting transcriber to a room")
 @app.async_command("join")
 async def join(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
-    agent_name: Annotated[str, typer.Option(..., help="Name of the agent")],
+    agent_name: Annotated[
+        Optional[str], typer.Option(..., help="Name of the agent")
+    ] = None,
     key: Annotated[
         str,
         typer.Option("--key", help="an api key to sign the token with"),
@@ -47,16 +49,24 @@ async def join(
         project_id = await resolve_project_id(project_id=project_id)
         room = resolve_room(room)
 
-        token = ParticipantToken(
-            name=agent_name,
-        )
+        jwt = os.getenv("MESHAGENT_TOKEN")
+        if jwt is None:
+            if agent_name is None:
+                print(
+                    "[bold red]--agent-name must be specified when the MESHAGENT_TOKEN environment variable is not set[/bold red]"
+                )
+                raise typer.Exit(1)
+
+            token = ParticipantToken(
+                name=agent_name,
+            )
 
-        token.add_api_grant(ApiScope.agent_default())
+            token.add_api_grant(ApiScope.agent_default())
 
-        token.add_role_grant(role="agent")
-        token.add_room_grant(room)
+            token.add_role_grant(role="agent")
+            token.add_room_grant(room)
 
-        jwt = token.to_jwt(api_key=key)
+            jwt = token.to_jwt(api_key=key)
 
         print("[bold green]Connecting to room...[/bold green]", flush=True)
         async with RoomClient(
@@ -70,7 +80,6 @@ async def join(
             requirements.append(RequiredSchema(name="transcript"))
 
             bot = MeetingTranscriber(
-                name=agent_name,
                 requires=requirements,
             )
 
@@ -93,9 +102,15 @@ async def join(
 async def service(
     *,
     agent_name: Annotated[str, typer.Option(..., help="Name of the agent")],
-    host: Annotated[Optional[str], typer.Option()] = None,
-    port: Annotated[Optional[int], typer.Option()] = None,
-    path: Annotated[str, typer.Option()] = "/agent",
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the service on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the service on")
+    ] = None,
+    path: Annotated[
+        str, typer.Option(help="HTTP path to mount the service at")
+    ] = "/agent",
 ):
     try:
         from meshagent.livekit.agents.meeting_transcriber import MeetingTranscriber
@@ -117,7 +132,6 @@ async def service(
     class CustomMeetingTranscriber(MeetingTranscriber):
         def __init__(self):
             super().__init__(
-                name=agent_name,
                 requires=requirements,
             )
 

meshagent/cli/messaging.py

@@ -16,13 +16,13 @@ from meshagent.cli.helper import (
     resolve_room,
 )
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Send and receive messages in a room")
 
 
-@app.async_command("list-participants")
+@app.async_command("list", help="List messaging-enabled participants")
 async def messaging_list_participants_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
 ):
     """
@@ -46,7 +46,6 @@ async def messaging_list_participants_command(
         ) as client:
             # Must enable before we can see who else is enabled
             await client.messaging.enable()
-            await client.messaging.start()
 
             participants = client.messaging.get_participants()
             output = []
@@ -61,10 +60,10 @@ async def messaging_list_participants_command(
         await account_client.close()
 
 
-@app.async_command("send")
+@app.async_command("send", help="Send a direct message to a participant")
 async def messaging_send_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     to_participant_id: Annotated[
         str, typer.Option(..., help="Participant ID to send a message to")
@@ -92,7 +91,6 @@ async def messaging_send_command(
         ) as client:
             # Create and enable messaging
             await client.messaging.enable()
-            await client.messaging.start()
 
             # Find the participant we want to message
             participant = None
@@ -120,10 +118,10 @@ async def messaging_send_command(
         await account_client.close()
 
 
-@app.async_command("broadcast")
+@app.async_command("broadcast", help="Broadcast a message to all participants")
 async def messaging_broadcast_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     data: Annotated[str, typer.Option(..., help="JSON message to broadcast")],
 ):
@@ -147,7 +145,6 @@ async def messaging_broadcast_command(
         ) as client:
             # Create and enable messaging
             await client.messaging.enable()
-            await client.messaging.start()
 
             # Broadcast the message
             await client.messaging.broadcast_message(