meshagent-cli 0.22.2__py3-none-any.whl

meshagent/cli/participant_token.py

@@ -0,0 +1,63 @@
+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(help="Generate participant tokens (JWTs)")
+
+
+@app.async_command("generate", help="Generate a participant token (JWT) from a spec")
+async def generate(
+    *,
+    project_id: ProjectIdOption,
+    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,
+):
+    """Generate a signed participant token (JWT) from a YAML spec."""
+
+    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/port.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import asyncio
+
+
+from typing import Annotated
+
+import typer
+
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption
+from meshagent.cli.helper import get_client, resolve_project_id
+
+from meshagent.api.port_forward import port_forward
+
+app = async_typer.AsyncTyper(help="Port forwarding into room containers")
+
+
+@app.async_command("forward", help="Forward a container port to localhost")
+async def forward(
+    *,
+    project_id: ProjectIdOption,
+    room: Annotated[
+        str,
+        typer.Option(
+            "--room",
+            "-r",
+            help="Room name containing the target container",
+        ),
+    ],
+    container_id: Annotated[
+        str,
+        typer.Option(
+            "--container-id",
+            "-c",
+            help="Container ID to port-forward into",
+        ),
+    ],
+    port: Annotated[
+        str,
+        typer.Option(
+            "--port",
+            "-p",
+            help="Port mapping in the form LOCAL:REMOTE",
+        ),
+    ],
+):
+    """Create a local TCP listener forwarding into a room container."""
+
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        connection = await client.connect_room(project_id=project_id, room=room)
+
+        ports = port.split(":")
+
+        handler = await port_forward(
+            listen_port=int(ports[0]),
+            port=int(ports[1]),
+            container_id=container_id,
+            token=connection.jwt,
+        )
+
+        await asyncio.sleep(10000)
+
+        await handler.close()
+
+    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,
+    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,
+    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()

meshagent/cli/room.py

@@ -0,0 +1,26 @@
+from meshagent.cli import async_typer
+from meshagent.cli import database
+from meshagent.cli import queue
+from meshagent.cli import agent
+from meshagent.cli import messaging
+from meshagent.cli import storage
+from meshagent.cli import developer
+from meshagent.cli import oauth2
+from meshagent.cli import containers
+
+from meshagent.cli import sync
+
+
+app = async_typer.AsyncTyper(help="Operate within a room")
+
+app.add_typer(agent.app, name="agents", help="Interact with agents and toolkits")
+app.add_typer(oauth2.app, name="secrets", help="Manage secrets for your project")
+app.add_typer(queue.app, name="queue", help="Use queues in a room")
+app.add_typer(messaging.app, name="messaging", help="Send and receive messages")
+app.add_typer(storage.app, name="storage", help="Manage storage for a room")
+app.add_typer(developer.app, name="developer", help="Developer utilities for a room")
+app.add_typer(database.app, name="database", help="Manage database tables in a room")
+app.add_typer(
+    containers.app, name="container", help="Manage containers and images in a room"
+)
+app.add_typer(sync.app, name="sync")

meshagent/cli/rooms.py

@@ -0,0 +1,214 @@
+# rooms_cli.py (add to the same module or import into your CLI package)
+
+import typer
+from rich import print
+from typing import Annotated, Optional
+import json
+
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import ProjectIdOption
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+)
+from meshagent.api import RoomException
+
+app = async_typer.AsyncTyper(help="Create, list, and manage rooms in a project")
+
+# ---------------------------
+# Helpers
+# ---------------------------
+
+
+async def _resolve_room_id_or_fail(
+    account_client, *, project_id: str, room_id: Optional[str], room_name: Optional[str]
+) -> str:
+    """
+    If room_id is provided, return it.
+    Else, resolve via room_name -> account_client.get_room(...).id
+    """
+    if room_id:
+        return room_id
+    if not room_name:
+        raise RoomException("You must provide either --id or --name.")
+    room = await account_client.get_room(project_id=project_id, name=room_name)
+    return room.id
+
+
+def _maybe_parse_json(label: str, s: Optional[str]):
+    if s is None:
+        return None
+    try:
+        return json.loads(s)
+    except json.JSONDecodeError as e:
+        raise RoomException(f"Invalid {label} JSON: {e}") from e
+
+
+# ---------------------------
+# Commands
+# ---------------------------
+
+
+@app.async_command("create")
+async def room_create_command(
+    *,
+    project_id: ProjectIdOption,
+    name: Annotated[str, typer.Option(..., help="Room name")],
+    if_not_exists: Annotated[
+        bool, typer.Option(help="Do not error if the room already exists")
+    ] = False,
+    metadata: Annotated[
+        Optional[str], typer.Option(help="Optional JSON object for room metadata")
+    ] = None,
+):
+    """
+    Create a room in the project.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+
+        meta_obj = _maybe_parse_json("metadata", metadata)
+
+        print(f"[bold green]Creating room {name}[/bold green]")
+        room = await account_client.create_room(
+            project_id=project_id,
+            name=name,
+            if_not_exists=if_not_exists,
+            metadata=meta_obj,
+        )
+
+        print(
+            json.dumps(
+                {"id": room.id, "name": room.name, "metadata": room.metadata}, indent=2
+            )
+        )
+
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("delete")
+async def room_delete_command(
+    *,
+    project_id: ProjectIdOption,
+    id: Annotated[Optional[str], typer.Option(help="Room ID (preferred)")] = None,
+    name: Optional[str] = None,
+):
+    """
+    Delete a room by ID (or by name if --name is supplied).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name) if name else None
+        rid = await _resolve_room_id_or_fail(
+            account_client, project_id=project_id, room_id=id, room_name=room_name
+        )
+
+        print(f"[bold yellow]Deleting room id={rid}...[/bold yellow]")
+        await account_client.delete_room(project_id=project_id, room_id=rid)
+        print("[bold cyan]Room deleted.[/bold cyan]")
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("update")
+async def room_update_command(
+    *,
+    project_id: ProjectIdOption,
+    id: Annotated[Optional[str], typer.Option(help="Room ID (preferred)")] = None,
+    name: Optional[str] = None,
+    new_name: Annotated[str, typer.Option(..., help="New room name")],
+):
+    """
+    Update a room's name (ID is preferred; name will be resolved to ID if needed).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name) if name else None
+        rid = await _resolve_room_id_or_fail(
+            account_client, project_id=project_id, room_id=id, room_name=room_name
+        )
+
+        print(
+            f"[bold green]Updating room id={rid} -> name='{new_name}'...[/bold green]"
+        )
+        await account_client.update_room(
+            project_id=project_id, room_id=rid, name=new_name
+        )
+        print("[bold cyan]Room updated.[/bold cyan]")
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list")
+async def room_list_command(
+    *,
+    project_id: ProjectIdOption,
+    limit: Annotated[
+        int, typer.Option(help="Max rooms to return", min=1, max=500)
+    ] = 50,
+    offset: Annotated[int, typer.Option(help="Offset for pagination", min=0)] = 0,
+    order_by: Annotated[
+        str, typer.Option(help='Order by column (e.g. "room_name", "created_at")')
+    ] = "room_name",
+):
+    """
+    List rooms in the project.
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        print("[bold green]Fetching rooms...[/bold green]")
+
+        rooms = await account_client.list_rooms(
+            project_id=project_id,
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+        )
+        output = [{"id": r.id, "name": r.name, "metadata": r.metadata} for r in rooms]
+        print(json.dumps(output, indent=2))
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()
+
+
+@app.async_command("get")
+async def room_get_command(
+    *,
+    project_id: ProjectIdOption,
+    name: Optional[str] = None,
+):
+    """
+    Get a single room by name (handy for resolving the ID).
+    """
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        room_name = resolve_room(name)
+
+        print(f"[bold green]Fetching room '{room_name}'...[/bold green]")
+        r = await account_client.get_room(project_id=project_id, name=room_name)
+        print(
+            json.dumps({"id": r.id, "name": r.name, "metadata": r.metadata}, indent=2)
+        )
+    except RoomException as ex:
+        print(f"[red]{ex}[/red]")
+        raise typer.Exit(1)
+    finally:
+        await account_client.close()