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

meshagent/cli/multi.py

@@ -0,0 +1,357 @@
+import typer
+from meshagent.cli import async_typer
+from meshagent.cli.host import run_services, set_deferred, service_specs, get_service
+from meshagent.cli.common_options import ProjectIdOption
+from typing import Annotated, Optional
+
+import importlib.util
+from pathlib import Path
+import click
+import shlex
+
+from rich import print
+
+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,
+)
+from aiohttp import ClientResponseError
+import asyncio
+
+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_service = async_typer.AsyncTyper(help="Add agents to a team")
+
+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_service.async_command("python")
+async def python(
+    *,
+    module: str,
+    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[
+        Optional[str],
+        typer.Option(help="A path to add the service at"),
+    ] = None,
+    identity: Annotated[
+        Optional[str],
+        typer.Option(help="The desired identity for the service"),
+    ] = None,
+    name: Annotated[
+        str, typer.Option(help="Entry-point name in the Python module")
+    ] = "main",
+):
+    service = get_service(host=host, port=port)
+
+    if path is None:
+        path = "/agent"
+        i = 0
+        while service.has_path(path):
+            i += 1
+            path = f"/agent{i}"
+
+    module = import_from_path(module)
+    service.add_path(path=path, identity=identity, cls=getattr(module, name or "main"))
+
+
+def execute_via_root(app, line: str, *, prog_name="meshagent") -> int:
+    cmd = get_command(app)
+    try:
+        cmd.main(args=shlex.split(line), prog_name=prog_name, standalone_mode=False)
+        return 0
+    except click.ClickException as e:
+        e.show()
+        return e.exit_code
+
+
+subcommand_help = """a list of sub commands to run, seperated by semicolons
+
+available sub commands:
+
+chatbot ...;
+mailbot ...;
+worker ...;
+voicebot ...;
+python path-to-python-file.py --name=NameOfModule;
+
+chatbot, worker, and mailbot command arguments mirror those of the respective meshagent chatbot service, meshagent mailbot service, meshagent voicebot service, and meshagent worker service commands.
+"""
+
+
+def build_spec(
+    *,
+    command: Annotated[str, typer.Option("-c", help=subcommand_help)],
+    service_name: Annotated[str, typer.Option("--service-name", help="service name")],
+    service_description: Annotated[
+        Optional[str], typer.Option("--service-description", help="service description")
+    ] = None,
+    service_title: Annotated[
+        Optional[str],
+        typer.Option("--service-title", help="a display name for the service"),
+    ] = None,
+):
+    for c in command.split(";"):
+        if execute_via_root(cli_service, c, prog_name="meshagent") != 0:
+            print(f"[red]{c} failed[/red]")
+            raise typer.Exit(1)
+
+    specs = service_specs()
+    if len(specs) == 0:
+        print("[red]found no services, specify at least one agent or tool to run[/red]")
+        raise typer.Exit(1)
+
+    if len(specs) > 1:
+        print(
+            "[red]found multiple services leave host and port empty or use the same port for each command[/red]"
+        )
+        raise typer.Exit(1)
+
+    spec = specs[0]
+    spec.metadata.annotations = {
+        "meshagent.service.id": service_name,
+    }
+    for port in spec.ports:
+        port.num = "*"
+
+    spec.metadata.name = service_name
+    spec.metadata.description = service_description
+    spec.container.image = (
+        "us-central1-docker.pkg.dev/meshagent-public/images/cli:{SERVER_VERSION}-esgz"
+    )
+    spec.container.command = (
+        f'meshagent multi service -c "{command.replace('"', '\\"')}"'
+    )
+
+
+@app.async_command("spec")
+async def spec(
+    command: Annotated[str, typer.Option("-c", help=subcommand_help)],
+    service_name: Annotated[str, typer.Option("--service-name", help="service name")],
+    service_description: Annotated[
+        Optional[str], typer.Option("--service-description", help="service description")
+    ] = None,
+    service_title: Annotated[
+        Optional[str],
+        typer.Option("--service-title", help="a display name for the service"),
+    ] = None,
+):
+    set_deferred(True)
+
+    spec = build_spec(
+        command=command,
+        service_name=service_name,
+        service_description=service_description,
+        service_title=service_title,
+    )
+
+    print(yaml.dump(spec.model_dump(mode="json", exclude_none=True), sort_keys=False))
+
+
+@app.async_command("deploy")
+async def deploy(
+    project_id: ProjectIdOption,
+    command: Annotated[str, typer.Option("-c", help=subcommand_help)],
+    service_name: Annotated[str, typer.Option("--service-name", help="service name")],
+    service_description: Annotated[
+        Optional[str], typer.Option("--service-description", help="service description")
+    ] = None,
+    service_title: Annotated[
+        Optional[str],
+        typer.Option("--service-title", help="a display name for the service"),
+    ] = None,
+    room: Annotated[
+        Optional[str],
+        typer.Option("--room", help="The name of a room to create the service for"),
+    ] = None,
+):
+    project_id = await resolve_project_id(project_id)
+
+    client = await get_client()
+    try:
+        set_deferred(True)
+
+        spec = build_spec(
+            command=command,
+            service_name=service_name,
+            service_description=service_description,
+            service_title=service_title,
+        )
+
+        spec.container.secrets = []
+
+        id = None
+        try:
+            if id is None:
+                if room is None:
+                    services = await client.list_services(project_id=project_id)
+                else:
+                    services = await client.list_room_services(
+                        project_id=project_id, room_name=room
+                    )
+
+                for s in services:
+                    if s.metadata.name == spec.metadata.name:
+                        id = s.id
+
+            if id is None:
+                if room is None:
+                    id = await client.create_service(
+                        project_id=project_id, service=spec
+                    )
+                else:
+                    id = await client.create_room_service(
+                        project_id=project_id, service=spec, room_name=room
+                    )
+
+            else:
+                spec.id = id
+                if room is None:
+                    await client.update_service(
+                        project_id=project_id, service_id=id, service=spec
+                    )
+                else:
+                    await client.update_room_service(
+                        project_id=project_id,
+                        service_id=id,
+                        service=spec,
+                        room_name=room,
+                    )
+
+        except ClientResponseError as exc:
+            if exc.status == 409:
+                print(f"[red]Service name already in use: {spec.metadata.name}[/red]")
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Deployed service:[/] {id}")
+
+    finally:
+        await client.close()
+
+
+@app.async_command("service")
+async def host(
+    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,
+    command: Annotated[str, typer.Option("-c", help=subcommand_help)] = [],
+):
+    set_deferred(True)
+
+    for c in command.split(";"):
+        if execute_via_root(cli_service, c, prog_name="meshagent") != 0:
+            print(f"[red]{c} failed[/red]")
+            raise typer.Exit(1)
+
+    await run_services()
+
+
+def import_from_path(path: str, module_name: str | None = None):
+    path = Path(path)
+    module_name = module_name or path.stem
+
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot load spec for {path}")
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+@app.async_command("join")
+async def join(
+    *,
+    project_id: ProjectIdOption,
+    command: Annotated[str, typer.Option("-c", help=subcommand_help)] = [],
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            "-p",
+            help=(
+                "a port number to run the agent on (will set MESHAGENT_PORT environment variable when launching the service)"
+            ),
+        ),
+    ] = None,
+    room: RoomOption,
+    key: Annotated[
+        str,
+        typer.Option("--key", help="an api key to sign the token with"),
+    ] = None,
+):
+    set_deferred(True)
+
+    if room is None:
+        print("[bold red]--room is required[/bold red]")
+        raise typer.Exit(-1)
+
+    for c in command.split(";"):
+        execute_via_root(cli_join, c + f" --room={room}", prog_name="meshagent")
+
+    from meshagent.cli.host import agents
+
+    try:
+
+        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])
+        )
+
+    except KeyboardInterrupt:
+        pass

meshagent/cli/oauth2.py

@@ -9,25 +9,52 @@ 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 = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
-    from_participant_id: Annotated[str, typer.Option()],
-    client_id: Annotated[str, typer.Option()],
-    authorization_endpoint: Annotated[str, typer.Option()],
-    token_endpoint: Annotated[str, typer.Option()],
-    scopes: Annotated[Optional[str], typer.Option()] = None,
-    client_secret: Annotated[Optional[str], typer.Option()],
-    redirect_uri: Annotated[Optional[str], typer.Option()],
-    pkce: Annotated[bool, typer.Option()] = True,
+    from_participant_id: Annotated[
+        str,
+        typer.Option(..., help="Participant ID to request the token from"),
+    ],
+    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")
+    ] = 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,
 ):
     """
     Run an OAuth2 request test between two participants in the same room.
@@ -69,29 +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 = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
-    delegated_to: Annotated[str, typer.Option()],
-    client_id: Annotated[str, typer.Option()],
-    authorization_endpoint: Annotated[str, typer.Option()],
-    token_endpoint: Annotated[str, typer.Option()],
-    scopes: Annotated[Optional[str], typer.Option()] = None,
-    client_secret: Annotated[Optional[str], typer.Option()],
-    redirect_uri: Annotated[Optional[str], typer.Option()],
-    pkce: Annotated[bool, typer.Option()] = True,
+    secret_id: Annotated[str, typer.Option(..., help="Secret ID")],
+    delegated_to: Annotated[
+        Optional[str],
+        typer.Option(help="Fetch a secret delegated to this participant name"),
+    ] = None,
+    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
         )
@@ -102,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()
@@ -124,7 +274,7 @@ async def get(
 @app.async_command("list")
 async def list(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
 ):
     """
@@ -145,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"))
@@ -159,10 +309,12 @@ async def list(
 @app.async_command("delete")
 async def delete(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     id: str,
-    delegated_to: Annotated[Optional[str], typer.Option()] = None,
+    delegated_to: Annotated[
+        str, typer.Option(help="The value of the delegated_to field of the secret")
+    ],
 ):
     """
     delete a secret
@@ -182,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/participant_token.py

@@ -10,13 +10,13 @@ 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()
+app = async_typer.AsyncTyper(help="Generate participant tokens (JWTs)")
 
 
-@app.async_command("generate")
+@app.async_command("generate", help="Generate a participant token (JWT) from a spec")
 async def generate(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     output: Annotated[
         Optional[str],
         typer.Option("--output", "-o", help="File path to a file"),
@@ -30,6 +30,8 @@ async def generate(
         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)