meshagent-cli 0.22.2__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

@@ -0,0 +1,138 @@
+import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+from meshagent.api import RoomClient, WebSocketClientProtocol, RoomException
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.cli import async_typer
+from meshagent.api import ParticipantToken, ApiScope
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+    resolve_key,
+)
+import os
+from meshagent.api import RequiredSchema
+from meshagent.api.services import ServiceHost
+
+app = async_typer.AsyncTyper(help="Join a meeting transcriber to a room")
+
+
+@app.async_command("join")
+async def join(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    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"),
+    ] = None,
+):
+    try:
+        from meshagent.livekit.agents.meeting_transcriber import MeetingTranscriber
+    except ImportError:
+
+        class MeetingTranscriber:
+            def __init__(self, **kwargs):
+                raise RoomException(
+                    "meshagent.livekit module not found, transcribers are not available"
+                )
+
+    key = await resolve_key(project_id=project_id, key=key)
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        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_role_grant(role="agent")
+            token.add_room_grant(room)
+
+            jwt = token.to_jwt(api_key=key)
+
+        print("[bold green]Connecting to room...[/bold green]", flush=True)
+        async with RoomClient(
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
+        ) as client:
+            requirements = []
+
+            requirements.append(RequiredSchema(name="transcript"))
+
+            bot = MeetingTranscriber(
+                requires=requirements,
+            )
+
+            await bot.start(room=client)
+
+            try:
+                print(
+                    f"[bold green]Open the studio to interact with your agent: {meshagent_base_url().replace('api.', 'studio.')}/projects/{project_id}/rooms/{client.room_name}[/bold green]",
+                    flush=True,
+                )
+                await client.protocol.wait_for_close()
+            except KeyboardInterrupt:
+                await bot.stop()
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("service")
+async def service(
+    *,
+    agent_name: Annotated[str, typer.Option(..., help="Name of the 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
+    except ImportError:
+
+        class MeetingTranscriber:
+            def __init__(self, **kwargs):
+                raise RoomException(
+                    "meshagent.livekit module not found, voicebots are not available"
+                )
+
+    requirements = []
+
+    requirements.append(RequiredSchema(name="transcript"))
+
+    service = ServiceHost(host=host, port=port)
+
+    @service.path(path=path)
+    class CustomMeetingTranscriber(MeetingTranscriber):
+        def __init__(self):
+            super().__init__(
+                requires=requirements,
+            )
+
+    await service.run()

meshagent/cli/messaging.py

@@ -0,0 +1,157 @@
+import typer
+from rich import print
+from typing import Annotated
+from meshagent.cli.common_options import (
+    ProjectIdOption,
+    RoomOption,
+)
+import json
+
+from meshagent.api import RoomClient, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+)
+
+app = async_typer.AsyncTyper(help="Send and receive messages in a room")
+
+
+@app.async_command("list", help="List messaging-enabled participants")
+async def messaging_list_participants_command(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+):
+    """
+    List all messaging-enabled participants in the room.
+    """
+    account_client = await get_client()
+    try:
+        # Resolve project_id if not provided
+        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:
+            # Must enable before we can see who else is enabled
+            await client.messaging.enable()
+
+            participants = client.messaging.get_participants()
+            output = []
+            for p in participants:
+                output.append({"id": p.id, "role": p.role, "attributes": p._attributes})
+
+            print(json.dumps(output, indent=2))
+
+            await client.messaging.stop()
+
+    finally:
+        await account_client.close()
+
+
+@app.async_command("send", help="Send a direct message to a participant")
+async def messaging_send_command(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    to_participant_id: Annotated[
+        str, typer.Option(..., help="Participant ID to send a message to")
+    ],
+    type: Annotated[str, typer.Option(..., help="type of the message to send")],
+    data: Annotated[str, typer.Option(..., help="JSON message to send")],
+):
+    """
+    Send a direct message to a single participant in the room.
+    """
+    account_client = await get_client()
+    try:
+        # Resolve project_id if not provided
+        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:
+            # Create and enable messaging
+            await client.messaging.enable()
+
+            # Find the participant we want to message
+            participant = None
+            for p in client.messaging.get_participants():
+                if p.id == to_participant_id:
+                    participant = p
+                    break
+
+            if participant is None:
+                print(
+                    f"[bold red]Participant with ID {to_participant_id} not found or not messaging-enabled.[/bold red]"
+                )
+            else:
+                # Send the message
+                await client.messaging.send_message(
+                    to=participant,
+                    type=type,
+                    message=json.loads(data),
+                    attachment=None,
+                )
+                print("[bold cyan]Message sent successfully.[/bold cyan]")
+
+            await client.messaging.stop()
+    finally:
+        await account_client.close()
+
+
+@app.async_command("broadcast", help="Broadcast a message to all participants")
+async def messaging_broadcast_command(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    data: Annotated[str, typer.Option(..., help="JSON message to broadcast")],
+):
+    """
+    Broadcast a message to all messaging-enabled participants in the room.
+    """
+    account_client = await get_client()
+    try:
+        # Resolve project_id if not provided
+        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:
+            # Create and enable messaging
+            await client.messaging.enable()
+
+            # Broadcast the message
+            await client.messaging.broadcast_message(
+                type="chat.broadcast", message=json.loads(data), attachment=None
+            )
+            print("[bold cyan]Broadcast message sent successfully.[/bold cyan]")
+
+            await client.messaging.stop()
+    finally:
+        await account_client.close()