meshagent-cli 0.0.17__py3-none-any.whl

meshagent/cli/messaging.py

@@ -0,0 +1,192 @@
+from meshagent.cli import async_typer
+import typer
+from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key
+from rich import print
+from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from typing import Annotated, Optional
+import json
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("list")
+async def messaging_list_participants_command(
+    *,
+    project_id: str = None,
+    room: Annotated[str, typer.Option()],
+    api_key_id: Annotated[Optional[str], typer.Option()] = None,
+    name: Annotated[str, typer.Option()] = "cli",
+    role: str = "user"
+):
+    """
+    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)
+        api_key_id = await resolve_api_key(project_id, api_key_id)
+
+        # Decrypt the API key
+        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+
+        # Build participant 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)
+
+        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)
+            )
+        ) 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 = []
+            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")
+async def messaging_send_command(
+    *,
+    project_id: str = None,
+    room: Annotated[str, typer.Option()],
+    api_key_id: Annotated[Optional[str], typer.Option()] = None,
+    name: Annotated[str, typer.Option()] = "cli",
+    role: str = "user",
+    to_participant_id: Annotated[str, typer.Option(..., help="Participant ID to send a message to")],
+    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)
+        api_key_id = await resolve_api_key(project_id, api_key_id)
+
+        # Decrypt the API key
+        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+
+        # Build participant 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)
+
+        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)
+            )
+        ) as client:
+            # Create and enable messaging
+            await client.messaging.enable()
+            await client.messaging.start()
+
+            # 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="chat.message",
+                    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")
+async def messaging_broadcast_command(
+    *,
+    project_id: str = None,
+    room: Annotated[str, typer.Option()],
+    api_key_id: Annotated[Optional[str], typer.Option()] = None,
+    name: Annotated[str, typer.Option()] = "cli",
+    role: str = "user",
+    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)
+        api_key_id = await resolve_api_key(project_id, api_key_id)
+
+        # Decrypt the API key
+        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+
+        # Build participant 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)
+
+        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)
+            )
+        ) as client:
+            # Create and enable messaging
+            await client.messaging.enable()
+            await client.messaging.start()
+
+            # 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()

meshagent/cli/participant_token.py

@@ -0,0 +1,33 @@
+from meshagent.cli import async_typer
+import typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
+from rich import print
+from meshagent.api import RoomClient, ParticipantToken
+from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id
+from typing import Annotated, Optional
+
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("generate")
+async def generate(*, project_id: str = None, room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option()], role: str = "agent"):
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        key = (await 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)
+
+        print(token.to_jwt(token=key))
+    
+    finally:
+        await client.close()

meshagent/cli/projects.py

@@ -0,0 +1,31 @@
+from meshagent.cli import async_typer
+import typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project
+from rich import print
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("list")
+async def list():
+    client = await get_client()
+    projects = await client.list_projects()
+    print_json_table(projects["projects"], "id", "name")
+    await client.close()
+
+@app.async_command("activate")
+async def activate(project_id: str):
+    client = await get_client()
+    try:
+        projects = await client.list_projects()
+        projects = projects["projects"]
+        for project in projects:
+            if project["id"] == project_id:
+                await set_active_project(project_id=project_id)
+                return
+
+        print(f"[red]Invalid project id: {project_id}[/red]")
+        raise typer.Exit(code=1)
+    finally:
+        await client.close()
+

meshagent/cli/services.py

@@ -0,0 +1,177 @@
+# ---------------------------------------------------------------------------
+#  Imports
+# ---------------------------------------------------------------------------
+from meshagent.cli import async_typer
+import typer
+from rich import print
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
+from typing import Annotated, List, Optional, Dict
+from datetime import datetime, timezone
+from pydantic_yaml import parse_yaml_raw_as, to_yaml_str
+from pydantic import PositiveInt
+import pydantic
+from typing import Literal
+
+# Pydantic basemodels
+from meshagent.api.accounts_client import Service, Port
+
+app = async_typer.AsyncTyper()
+
+# ---------------------------------------------------------------------------
+#  Utilities
+# ---------------------------------------------------------------------------
+
+def _kv_to_dict(pairs: List[str]) -> Dict[str, str]:
+    """Convert ["A=1","B=2"] → {"A":"1","B":"2"}."""
+    out: Dict[str, str] = {}
+    for p in pairs:
+        if "=" not in p:
+            raise typer.BadParameter(f"'{p}' must be KEY=VALUE")
+        k, v = p.split("=", 1)
+        out[k] = v
+    return out
+
+class PortSpec(pydantic.BaseModel):
+    """
+    CLI schema for --port.
+    Example:
+        --port num=8080 type=webserver liveness=/health
+    """
+    num: PositiveInt
+    type: Literal["mcp.sse", "meshagent.callable", "http", "tcp"]
+    liveness: str | None = None
+    participant_name: str | None = None
+
+def _parse_port_spec(spec: str) -> PortSpec:
+    """
+    Convert "num=8080 type=webserver liveness=/health" → PortSpec.
+    The user should quote the whole string if it contains spaces.
+    """
+    tokens = spec.strip().split()
+    kv: Dict[str, str] = {}
+    for t in tokens:
+        if "=" not in t:
+            raise typer.BadParameter(f"expected key=value, got '{t}'")
+        k, v = t.split("=", 1)
+        kv[k] = v
+    try:
+        return PortSpec(**kv)
+    except pydantic.ValidationError as exc:
+        raise typer.BadParameter(str(exc))
+
+
+# ---------------------------------------------------------------------------
+#  Commands
+# ---------------------------------------------------------------------------
+
+@app.async_command("create")
+async def service_create(
+    *,
+    project_id: str = None,
+    name: Annotated[str, typer.Option(help="Friendly service name")],
+    image: Annotated[str, typer.Option(help="Container image reference")],
+    pull_secret: Annotated[
+        Optional[str],
+        typer.Option("--pull-secret", help="Secret ID for registry"),
+    ] = None,
+    command: Annotated[
+        Optional[str],
+        typer.Option("--command", help="Override ENTRYPOINT/CMD"),
+    ] = None,
+    env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
+    env_secret: Annotated[List[str], typer.Option("--env-secret")] = [],
+    runtime_secret: Annotated[List[str], typer.Option("--runtime-secret")] = [],
+    room_storage_path: Annotated[
+        Optional[str],
+        typer.Option("--mount", help="Path inside container to mount room storage"),
+    ] = None,
+    port: Annotated[
+        List[str],
+        typer.Option(
+            "--port",
+            "-p",
+            help=(
+                'Repeatable. Example:\n'
+                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health"'
+            ),
+        ),
+    ] = [],
+):
+    """Create a service attached to the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        # ✅ validate / coerce port specs
+        port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+
+        ports_dict = (
+            {
+                ps.num: Port(
+                    type=ps.type,
+                    liveness=ps.liveness,
+                    participant_name=ps.participant_name,
+                )
+                for ps in port_specs
+            }
+            or None
+        )
+
+        service_obj = Service(
+            id="",
+            created_at=datetime.now(timezone.utc).isoformat(),
+            name=name,
+            image=image,
+            command=command,
+            pull_secret=pull_secret,
+            room_storage_path=room_storage_path,
+            environment=_kv_to_dict(env),
+            environment_secrets=env_secret or None,
+            runtime_secrets=_kv_to_dict(runtime_secret),
+            ports=ports_dict,
+        )
+
+        new_id = (await client.create_service(project_id=project_id, service=service_obj))["id"]
+        print(f"[green]Created service:[/] {new_id}")
+
+    finally:
+        await client.close()
+
+@app.async_command("show")
+async def service_show(*, project_id: str = None, service_id: Annotated[str, typer.Argument(help="ID of the service to delete")],):
+    """Show a services for the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        service = await client.get_service(project_id=project_id, service_id=service_id)     # → List[Service]
+        print(service.model_dump(mode="json"))
+    finally:
+        await client.close()
+
+
+@app.async_command("list")
+async def service_list(*, project_id: str = None):
+    """List all services for the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        services : list[Service] = await client.list_services(project_id=project_id)     # → List[Service]
+        print_json_table([svc.model_dump(mode="json") for svc in services], "id", "name", "image", "command", "room_storage_path", "pull_secret", "environment_secrets", "ports")
+    finally:
+        await client.close()
+
+
+@app.async_command("delete")
+async def service_delete(
+    *,
+    project_id: Optional[str] = None,
+    service_id: Annotated[str, typer.Argument(help="ID of the service to delete")],
+):
+    """Delete a service."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        await client.delete_service(project_id=project_id, service_id=service_id)
+        print(f"[green]Service {service_id} deleted.[/]")
+    finally:
+        await client.close()

meshagent/cli/sessions.py

@@ -0,0 +1,19 @@
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("list")
+async def list(*, project_id: str = None):
+    client = await get_client()
+    sessions = await client.list_recent_sessions(project_id=await resolve_project_id(project_id=project_id))
+    print_json_table(sessions["sessions"])
+    await client.close()
+
+
+@app.async_command("show")
+async def show(*, project_id: str = None, session_id: str):
+    client = await get_client()
+    events = await client.list_session_events(project_id=await resolve_project_id(project_id=project_id), session_id=session_id)
+    print_json_table(events["events"], "type", "data")
+    await client.close()