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

meshagent/cli/multi.py

@@ -10,45 +10,54 @@ import click
 import shlex
 
 from rich import print
-from meshagent.cli.call import _make_call
-import sys
+
+from meshagent.agents import Agent
 
 from typer.main import get_command
 
+from meshagent.cli.common_options import RoomOption
 from meshagent.cli.helper import (
     get_client,
     resolve_project_id,
-    resolve_room,
-    resolve_key,
-)
-from meshagent.api import (
-    ParticipantToken,
-    ApiScope,
 )
 from aiohttp import ClientResponseError
 import asyncio
 
-from meshagent.api.keys import parse_api_key
+from meshagent.api import RoomClient
+
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.api.websocket_protocol import WebSocketClientProtocol
 
 from meshagent.cli.chatbot import service as chatbot_service
 from meshagent.cli.worker import service as worker_service
 from meshagent.cli.mailbot import service as mailbot_service
 from meshagent.cli.voicebot import service as voicebot_service
 
+from meshagent.cli.chatbot import join as chatbot_join
+from meshagent.cli.worker import join as worker_join
+from meshagent.cli.mailbot import join as mailbot_join
+from meshagent.cli.voicebot import join as voicebot_join
+
 import yaml
 
 
 app = async_typer.AsyncTyper(help="Connect agents and tools to a room")
 
-cli = async_typer.AsyncTyper(help="Add agents to a team")
+cli_service = async_typer.AsyncTyper(help="Add agents to a team")
 
-cli.command("chatbot")(chatbot_service)
-cli.command("worker")(worker_service)
-cli.command("mailbot")(mailbot_service)
-cli.command("voicebot")(voicebot_service)
+cli_service.command("chatbot")(chatbot_service)
+cli_service.command("worker")(worker_service)
+cli_service.command("mailbot")(mailbot_service)
+cli_service.command("voicebot")(voicebot_service)
 
+cli_join = async_typer.AsyncTyper(help="Add agents to a team")
+cli_join.command("chatbot")(chatbot_join)
+cli_join.command("worker")(worker_join)
+cli_join.command("mailbot")(mailbot_join)
+cli_join.command("voicebot")(voicebot_join)
 
-@cli.async_command("python")
+
+@cli_service.async_command("python")
 async def python(
     *,
     module: str,
@@ -120,7 +129,7 @@ def build_spec(
     ] = None,
 ):
     for c in command.split(";"):
-        if execute_via_root(cli, c, prog_name="meshagent") != 0:
+        if execute_via_root(cli_service, c, prog_name="meshagent") != 0:
             print(f"[red]{c} failed[/red]")
             raise typer.Exit(1)
 
@@ -271,7 +280,7 @@ async def host(
     set_deferred(True)
 
     for c in command.split(";"):
-        if execute_via_root(cli, c, prog_name="meshagent") != 0:
+        if execute_via_root(cli_service, c, prog_name="meshagent") != 0:
             print(f"[red]{c} failed[/red]")
             raise typer.Exit(1)
 
@@ -306,12 +315,7 @@ async def join(
             ),
         ),
     ] = None,
-    room: Annotated[
-        Optional[str],
-        typer.Option(
-            help="A room name to test the service in (must not be currently running)"
-        ),
-    ] = None,
+    room: RoomOption,
     key: Annotated[
         str,
         typer.Option("--key", help="an api key to sign the token with"),
@@ -319,84 +323,35 @@ async def join(
 ):
     set_deferred(True)
 
-    for c in command.split(";"):
-        if execute_via_root(cli, c, prog_name="meshagent") != 0:
-            print(f"[red]{c} failed[/red]")
-            raise typer.Exit(1)
-
-    services_task = asyncio.create_task(run_services())
+    if room is None:
+        print("[bold red]--room is required[/bold red]")
+        raise typer.Exit(-1)
 
-    key = await resolve_key(project_id=project_id, key=key)
-
-    if port is None:
-        import socket
-
-        def find_free_port():
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind(("", 0))  # Bind to a free port provided by the host.
-                s.listen(1)
-                return s.getsockname()[1]
+    for c in command.split(";"):
+        execute_via_root(cli_join, c + f" --room={room}", prog_name="meshagent")
 
-        port = find_free_port()
+    from meshagent.cli.host import agents
 
-    my_client = await get_client()
     try:
-        project_id = await resolve_project_id(project_id)
-        room = resolve_room(room)
-
-        if room is None:
-            print("[bold red]Room was not set[/bold red]")
-            raise typer.Exit(1)
-
-        try:
-            parsed_key = parse_api_key(key)
-            token = ParticipantToken(
-                name="cli", project_id=project_id, api_key_id=parsed_key.id
-            )
-            token.add_api_grant(ApiScope.agent_default())
-            token.add_role_grant("user")
-            token.add_room_grant(room)
-
-            print("[bold green]Connecting to room...[/bold green]")
-
-            run_tasks = []
-
-            for spec in service_specs():
-                sys.stdout.write("\n")
-
-                for p in spec.ports:
-                    print(f"[bold green]Connecting port {p.num}...[/bold green]")
-
-                    for endpoint in p.endpoints:
-                        print(
-                            f"[bold green]Connecting endpoint {endpoint.path}...[/bold green]"
-                        )
-
-                        run_tasks.append(
-                            asyncio.create_task(
-                                _make_call(
-                                    room=room,
-                                    project_id=project_id,
-                                    participant_name=endpoint.meshagent.identity,
-                                    url=f"http://localhost:{p.num}{endpoint.path}",
-                                    arguments={},
-                                    key=key,
-                                    permissions=endpoint.meshagent.api,
-                                )
-                            )
-                        )
-
-                await asyncio.gather(*run_tasks, services_task)
 
-        except ClientResponseError as exc:
-            if exc.status == 409:
-                print(f"[red]Room already in use: {room}[/red]")
-                raise typer.Exit(code=1)
-            raise
-
-        except Exception as e:
-            print(f"[red]{e}[/red]")
-            raise typer.Exit(code=1)
+        async def run_agent(agent: Agent, jwt: str):
+            nonlocal room
+
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(
+                    url=websocket_room_url(
+                        room_name=room, base_url=meshagent_base_url()
+                    ),
+                    token=jwt,
+                )
+            ) as room:
+                await agent.start(room=room)
+                await room.protocol.wait_for_close()
+                await agent.stop()
+
+        await asyncio.gather(
+            *([asyncio.create_task(run_agent(agent, jwt)) for agent, jwt in agents])
+        )
 
-    finally:
-        await my_client.close()
+    except KeyboardInterrupt:
+        pass

meshagent/cli/oauth2.py

@@ -9,13 +9,29 @@ from meshagent.api import RoomClient, WebSocketClientProtocol
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from rich import print
 from typing import Annotated, Optional
+from pathlib import Path
 import typer
 import json
+import sys
 
 app = async_typer.AsyncTyper(help="OAuth2 test commands")
 
 
-@app.async_command("request")
+def _read_bytes(*, input_path: str) -> bytes:
+    if input_path == "-":
+        return sys.stdin.buffer.read()
+    return Path(input_path).expanduser().resolve().read_bytes()
+
+
+def _write_bytes(*, output_path: str, data: bytes) -> None:
+    if output_path == "-":
+        sys.stdout.buffer.write(data)
+        sys.stdout.buffer.flush()
+        return
+    Path(output_path).expanduser().resolve().write_bytes(data)
+
+
+@app.async_command("oauth")
 async def oauth2(
     *,
     project_id: ProjectIdOption,
@@ -80,39 +96,157 @@ async def oauth2(
         await account_client.close()
 
 
+@app.async_command("request")
+async def secret_request(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    from_participant_id: Annotated[
+        str,
+        typer.Option(..., help="Participant ID to request the secret from"),
+    ],
+    url: Annotated[str, typer.Option(..., help="Secret URL identifier")],
+    mime_type: Annotated[
+        str, typer.Option("--type", help="Secret MIME type")
+    ] = "application/octet-stream",
+    delegate_to: Annotated[
+        Optional[str],
+        typer.Option(help="Delegate secret to this participant name"),
+    ] = None,
+    timeout: Annotated[int, typer.Option(help="Timeout in seconds")] = 300,
+    out: Annotated[
+        str,
+        typer.Option(
+            "--out",
+            "-o",
+            help="Output file path, or '-' for stdout",
+        ),
+    ] = "-",
+):
+    """Request a secret from another participant."""
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            typer.echo(
+                f"Requesting secret from participant {from_participant_id}...",
+                err=True,
+            )
+            secret = await consumer.secrets.request_secret(
+                url=url,
+                type=mime_type,
+                timeout=timeout,
+                from_participant_id=from_participant_id,
+                delegate_to=delegate_to,
+            )
+
+            _write_bytes(output_path=out, data=secret)
+            if out != "-":
+                typer.echo(f"Wrote {len(secret)} bytes to {out}", err=True)
+
+    finally:
+        await account_client.close()
+
+
 @app.async_command("get")
-async def get(
+async def secret_get(
     *,
     project_id: ProjectIdOption,
     room: RoomOption,
+    secret_id: Annotated[str, typer.Option(..., help="Secret ID")],
     delegated_to: Annotated[
-        str, typer.Option(..., help="Participant ID to delegate the token to")
-    ],
-    client_id: Annotated[str, typer.Option(..., help="OAuth client ID")],
-    authorization_endpoint: Annotated[
-        str, typer.Option(..., help="OAuth authorization endpoint URL")
-    ],
-    token_endpoint: Annotated[str, typer.Option(..., help="OAuth token endpoint URL")],
-    scopes: Annotated[
-        Optional[str], typer.Option(help="Comma-separated OAuth scopes")
+        Optional[str],
+        typer.Option(help="Fetch a secret delegated to this participant name"),
     ] = None,
-    client_secret: Annotated[
-        Optional[str], typer.Option(help="OAuth client secret (if required)")
-    ],
-    redirect_uri: Annotated[
-        Optional[str], typer.Option(help="Redirect URI for the OAuth flow")
-    ],
-    pkce: Annotated[bool, typer.Option(help="Use PKCE (recommended)")] = True,
+    out: Annotated[
+        str,
+        typer.Option(
+            "--out",
+            "-o",
+            help="Output file path, or '-' for stdout",
+        ),
+    ] = "-",
 ):
-    """
-    Run an OAuth2 request test between two participants in the same room.
-    One will act as the consumer, the other as the provider.
-    """
+    """Get a stored secret by secret id."""
 
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
+        jwt_consumer = 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=jwt_consumer.jwt,
+            )
+        ) as consumer:
+            resp = await consumer.secrets.get_secret(
+                secret_id=secret_id,
+                delegated_to=delegated_to,
+            )
+
+            if resp is None:
+                typer.echo("Secret not found", err=True)
+                raise typer.Exit(1)
+
+            typer.echo(
+                f"Got secret name={resp.name} mime_type={resp.mime_type} bytes={len(resp.data)}",
+                err=True,
+            )
+            _write_bytes(output_path=out, data=resp.data)
+            if out != "-":
+                typer.echo(f"Wrote {len(resp.data)} bytes to {out}", err=True)
+
+    finally:
+        await account_client.close()
 
+
+@app.async_command("set")
+async def secret_set(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    secret_id: Annotated[str, typer.Option(..., help="Secret ID")],
+    mime_type: Annotated[
+        Optional[str],
+        typer.Option("--type", help="Secret MIME type"),
+    ] = None,
+    name: Annotated[
+        Optional[str],
+        typer.Option(help="Optional secret name"),
+    ] = None,
+    delegated_to: Annotated[
+        Optional[str],
+        typer.Option(help="Store a secret delegated to this participant name"),
+    ] = None,
+    input_path: Annotated[
+        str,
+        typer.Option(
+            "--in",
+            "-i",
+            help="Input file path, or '-' for stdin",
+        ),
+    ] = "-",
+):
+    """Set/store a secret (bytes from stdin or file)."""
+
+    secret_bytes = _read_bytes(input_path=input_path)
+
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
         jwt_consumer = await account_client.connect_room(
             project_id=project_id, room=room
         )
@@ -123,20 +257,15 @@ async def get(
                 token=jwt_consumer.jwt,
             )
         ) as consumer:
-            print("[green]Requesting OAuth token from consumer side...[/green]")
-            token = await consumer.secrets.get_offline_oauth_token(
-                oauth=OAuthClientConfig(
-                    client_id=client_id,
-                    authorization_endpoint=authorization_endpoint,
-                    token_endpoint=token_endpoint,
-                    scopes=scopes.split(",") if scopes is not None else scopes,
-                    client_secret=client_secret,
-                    no_pkce=not pkce,
-                ),
+            await consumer.secrets.set_secret(
+                secret_id=secret_id,
+                type=mime_type,
+                name=name,
                 delegated_to=delegated_to,
+                data=secret_bytes,
             )
 
-            print(f"[bold cyan]Got access token:[/bold cyan] {token}")
+            typer.echo(f"Stored {len(secret_bytes)} bytes", err=True)
 
     finally:
         await account_client.close()
@@ -166,7 +295,7 @@ async def list(
                 token=jwt_consumer.jwt,
             )
         ) as consumer:
-            secrets = await consumer.secrets.list_user_secrets()
+            secrets = await consumer.secrets.list_secrets()
             output = []
             for s in secrets:
                 output.append(s.model_dump(mode="json"))
@@ -205,7 +334,7 @@ async def delete(
                 token=jwt_consumer.jwt,
             )
         ) as consumer:
-            await consumer.secrets.delete_user_secret(id=id, delegated_to=delegated_to)
+            await consumer.secrets.delete_secret(id=id, delegated_to=delegated_to)
             print("deleted secret")
 
     finally:

meshagent/cli/room.py

@@ -5,13 +5,16 @@ from meshagent.cli import agent
 from meshagent.cli import messaging
 from meshagent.cli import storage
 from meshagent.cli import developer
-from meshagent.cli import cli_secrets
+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(cli_secrets.app, name="secret", help="Manage secrets for your project")
+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")
@@ -20,3 +23,4 @@ app.add_typer(database.app, name="database", help="Manage database tables in a r
 app.add_typer(
     containers.app, name="container", help="Manage containers and images in a room"
 )
+app.add_typer(sync.app, name="sync")