meshagent-cli 0.0.17__py3-none-any.whl

meshagent/cli/cli_mcp.py

@@ -0,0 +1,113 @@
+
+from mcp.client.session import ClientSession
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client, StdioServerParameters
+
+from meshagent.mcp import MCPToolkit
+
+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, WebSocketClientProtocol, RoomException
+from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, resolve_api_key
+from typing import Annotated, Optional
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+
+from meshagent.api.services import send_webhook
+from meshagent.tools.hosting import RemoteToolkit
+import shlex
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("sse")
+async def sse(*, project_id: str = None, room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option(..., help="Participant name")] = "cli", role: str = "tool", url: Annotated[str, typer.Option()]):
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        api_key_id = await resolve_api_key(project_id, api_key_id)
+
+        key = (await account_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("[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:
+            
+            async with sse_client(url) as (read_stream, write_stream):
+
+                async with ClientSession(read_stream=read_stream, write_stream=write_stream) as session:
+                    
+                    mcp_tools_response = await session.list_tools()
+                    
+                    toolkit = MCPToolkit(name=name, session=session, tools=mcp_tools_response.tools)
+                    
+                    remote_toolkit = RemoteToolkit(name=toolkit.name, tools=toolkit.tools, title=toolkit.title, description=toolkit.description)
+
+                    await remote_toolkit.start(room=client)
+                    try:
+                        await client.protocol.wait_for_close()
+                    except KeyboardInterrupt:
+                        await remote_toolkit.stop()
+
+
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()
+
+
+
+@app.async_command("stdio")
+async def stdio(*, project_id: str = None, room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option(..., help="Participant name")] = "cli", role: str = "tool", command: Annotated[str, typer.Option()], args: Annotated[str, typer.Option()]):
+    account_client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        api_key_id = await resolve_api_key(project_id, api_key_id)
+
+        key = (await account_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("[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:
+            
+            async with stdio_client(StdioServerParameters(
+                    command=command,  # Executable
+                    args=shlex.split(args),  # Optional command line arguments
+                    env=None,  # Optional environment variables
+                )) as (read_stream, write_stream):
+
+                async with ClientSession(read_stream=read_stream, write_stream=write_stream) as session:
+                    
+                    mcp_tools_response = await session.list_tools()
+                    
+                    toolkit = MCPToolkit(name=name, session=session, tools=mcp_tools_response.tools)
+                    
+                    remote_toolkit = RemoteToolkit(name=toolkit.name, tools=toolkit.tools, title=toolkit.title, description=toolkit.description)
+
+                    await remote_toolkit.start(room=client)
+                    try:
+                        await client.protocol.wait_for_close()
+                    except KeyboardInterrupt:
+                        await remote_toolkit.stop()
+
+
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()

meshagent/cli/cli_secrets.py

@@ -0,0 +1,383 @@
+# --------------------------------------------------------------------------
+#  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, Dict, Optional
+
+from meshagent.api.accounts_client import PullSecret, KeysSecret, SecretLike   # or wherever you defined them
+
+# --------------------------------------------------------------------------
+#  App Definition
+# --------------------------------------------------------------------------
+secrets_app = async_typer.AsyncTyper(help="Manage secrets for your project.")
+
+
+# --------------------------------------------------------------------------
+#  Utility helpers
+# --------------------------------------------------------------------------
+
+def _parse_kv_inline(source: str | None) -> Dict[str, str]:
+    """
+    Parse a space-separated list of `key=value` tokens into a dict.
+    """
+    if source is None:
+        return {}
+    tokens = source.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
+    return kv
+
+
+# --------------------------------------------------------------------------
+#  Subcommand group: "keys"
+#     e.g.: meshagent secrets keys create --name <NAME> --data ...
+# --------------------------------------------------------------------------
+keys_app = async_typer.AsyncTyper(help="Create or update environment-based key-value secrets.")
+
+@keys_app.async_command("create")
+async def create_keys_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    name: Annotated[str, typer.Option(help="Secret name")],
+    data: Annotated[
+        str,
+        typer.Option(
+            "--data",
+            help="Format: key=value key2=value  (space-separated)",
+        ),
+    ]
+):
+    """
+    Create a new 'keys' secret (opaque env-vars).
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        data_dict = _parse_kv_inline(data)
+
+        secret_obj = KeysSecret(
+            id="",
+            name=name,
+            data=data_dict,
+        )
+        secret_id = await client.create_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Created keys secret:[/] {secret_id}")
+
+    finally:
+        await client.close()
+
+
+@keys_app.async_command("update")
+async def update_keys_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
+    name: Annotated[str, typer.Option(help="Secret name")],
+    data: Annotated[
+        str,
+        typer.Option(
+            "--data",
+            help="Format: key=value key2=value  (space-separated)",
+        ),
+    ]
+):
+    """
+    Update an existing 'keys' secret (opaque env-vars).
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        data_dict = _parse_kv_inline(data)
+
+        secret_obj = KeysSecret(
+            id=secret_id,
+            name=name,
+            data=data_dict,
+        )
+        await client.update_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Keys secret {secret_id} updated.[/]")
+    finally:
+        await client.close()
+
+
+# --------------------------------------------------------------------------
+#  Subcommand group: "docker"
+#     e.g.: meshagent secrets docker create --name myregistry --server ...
+# --------------------------------------------------------------------------
+docker_app = async_typer.AsyncTyper(help="Create or update a Docker registry pull secret.")
+
+@docker_app.async_command("create")
+async def create_docker_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="Docker registry server, e.g. index.docker.io")],
+    username: Annotated[str, typer.Option(help="Registry user name")],
+    password: Annotated[str, typer.Option(help="Registry password")],
+    email: Annotated[
+        str,
+        typer.Option("--email", help="User email for Docker config", show_default=False)
+    ] = "none@example.com"
+):
+    """
+    Create a new Docker pull secret (generic).
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        secret_obj = PullSecret(
+            id="",
+            name=name,
+            server=server,
+            username=username,
+            password=password,
+            email=email,
+        )
+        secret_id = await client.create_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Created Docker pull secret:[/] {secret_id}")
+    finally:
+        await client.close()
+
+
+@docker_app.async_command("update")
+async def update_docker_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="Docker registry server")],
+    username: Annotated[str, typer.Option(help="Registry user name")],
+    password: Annotated[str, typer.Option(help="Registry password")],
+    email: Annotated[
+        str,
+        typer.Option("--email", help="User email for Docker config", show_default=False)
+    ] = "none@example.com"
+):
+    """
+    Update an existing Docker pull secret (generic).
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        secret_obj = PullSecret(
+            id=secret_id,
+            name=name,
+            server=server,
+            username=username,
+            password=password,
+            email=email,
+        )
+        await client.update_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Docker pull secret {secret_id} updated.[/]")
+    finally:
+        await client.close()
+
+
+# --------------------------------------------------------------------------
+#  Subcommand group: "acr"
+#     e.g.: meshagent secrets acr create --name <NAME> --server <REG>.azurecr.io ...
+# --------------------------------------------------------------------------
+acr_app = async_typer.AsyncTyper(help="Create or update an Azure Container Registry pull secret.")
+
+@acr_app.async_command("create")
+async def create_acr_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="ACR server, e.g. myregistry.azurecr.io")],
+    username: Annotated[str, typer.Option(help="Service principal ID")],
+    password: Annotated[str, typer.Option(help="Service principal secret/password")]
+):
+    """
+    Create a new ACR pull secret (defaults email to 'none@microsoft.com').
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        secret_obj = PullSecret(
+            id="",
+            name=name,
+            server=server,
+            username=username,
+            password=password,
+            email="none@microsoft.com",   # Set a default for ACR usage
+        )
+        secret_id = await client.create_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Created ACR pull secret:[/] {secret_id}")
+    finally:
+        await client.close()
+
+@acr_app.async_command("update")
+async def update_acr_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="ACR server, e.g. myregistry.azurecr.io")],
+    username: Annotated[str, typer.Option(help="Service principal ID")],
+    password: Annotated[str, typer.Option(help="Service principal secret/password")]
+):
+    """
+    Update an existing ACR pull secret (defaults email to 'none@microsoft.com').
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        secret_obj = PullSecret(
+            id=secret_id,
+            name=name,
+            server=server,
+            username=username,
+            password=password,
+            email="none@microsoft.com",
+        )
+        await client.update_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]ACR pull secret {secret_id} updated.[/]")
+    finally:
+        await client.close()
+
+
+# --------------------------------------------------------------------------
+#  Subcommand group: "gar"
+#     e.g.: meshagent secrets gar create --name <NAME> --server ...
+#           (Typically sets email='none@google.com' and username='_json_key')
+# --------------------------------------------------------------------------
+gar_app = async_typer.AsyncTyper(help="Create or update a Google Artifact Registry pull secret.")
+
+@gar_app.async_command("create")
+async def create_gar_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="GAR host, e.g. us-west1-docker.pkg.dev")],
+    json_key: Annotated[str, typer.Option(help="Entire GCP service account JSON as string")]
+):
+    """
+    Create a new Google Artifact Registry pull secret.
+    
+    By default, sets email='none@google.com', username='_json_key'
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        secret_obj = PullSecret(
+            id="",
+            name=name,
+            server=server,
+            username="_json_key",
+            password=json_key,
+            email="none@google.com",
+        )
+        secret_id = await client.create_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]Created GAR pull secret:[/] {secret_id}")
+    finally:
+        await client.close()
+
+@gar_app.async_command("update")
+async def update_gar_secret(
+    *,
+    project_id: Optional[str] = typer.Option(None),
+    secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
+    name: Annotated[str, typer.Option(help="Secret name")],
+    server: Annotated[str, typer.Option(help="GAR host, e.g. us-west1-docker.pkg.dev")],
+    json_key: Annotated[str, typer.Option(help="Entire GCP service account JSON as string")]
+):
+    """
+    Update an existing Google Artifact Registry pull secret.
+    """
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        secret_obj = PullSecret(
+            id=secret_id,
+            name=name,
+            server=server,
+            username="_json_key",
+            password=json_key,
+            email="none@google.com",
+        )
+        await client.update_secret(project_id=project_id, secret=secret_obj)
+        print(f"[green]GAR pull secret {secret_id} updated.[/]")
+    finally:
+        await client.close()
+
+
+# --------------------------------------------------------------------------
+#  Additional commands (shared by all secrets): list, delete
+# --------------------------------------------------------------------------
+
+@secrets_app.async_command("list")
+async def secret_list(*, project_id: Optional[str] = None):
+    """List all secrets in the project (typed as Docker/ACR/GAR or Keys secrets)."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        secrets: list[SecretLike] = await client.list_secrets(project_id)
+
+        # Convert each secret → plain dict for tabular output
+        rows = []
+        for s in secrets:
+            row = {
+                "id":   s.id,
+                "name": s.name,
+                "type": s.type,
+            }
+            # If it's a KeysSecret, row["data_keys"] = ...
+            if hasattr(s, "data"):
+                # For Docker-ish secrets, 'data' typically has server/username/password
+                if isinstance(s, PullSecret):
+                    row["data_keys"] = "server, username, password"
+                else:
+                    # KeysSecret
+                    row["data_keys"] = ", ".join(s.data.keys())
+            rows.append(row)
+
+        print_json_table(rows, "id", "type", "name", "data_keys")
+
+    finally:
+        await client.close()
+
+
+@secrets_app.async_command("delete")
+async def secret_delete(
+    *,
+    project_id: Optional[str] = None,
+    secret_id: Annotated[str, typer.Argument(help="ID of the secret to delete")]
+):
+    """Delete a secret."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id=project_id)
+        await client.delete_secret(project_id=project_id, secret_id=secret_id)
+        print(f"[green]Secret {secret_id} deleted.[/]")
+    finally:
+        await client.close()
+
+
+# --------------------------------------------------------------------------
+#  Wire up sub-apps
+# --------------------------------------------------------------------------
+secrets_app.add_typer(keys_app, name="keys")
+secrets_app.add_typer(docker_app, name="docker")
+secrets_app.add_typer(acr_app, name="acr")
+secrets_app.add_typer(gar_app, name="gar")
+
+app = secrets_app
+
+
+# If you want to attach `secrets_app` to your main CLI app, do something like:
+# main_app = async_typer.AsyncTyper()
+# main_app.add_typer(secrets_app, name="secrets")
+# if __name__ == "__main__":
+#     main_app()

meshagent/cli/developer.py

@@ -0,0 +1,76 @@
+import asyncio
+import json
+from meshagent.cli import async_typer
+import typer
+from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key
+from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from rich import print
+from typing import Annotated, Optional
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("watch")
+async def watch_logs(
+    *,
+    project_id: Annotated[Optional[str], typer.Option(..., help="Project ID (if not set, will try to use the active project)")] = None,
+    room: Annotated[str, typer.Option(..., help="Name of the room to connect to")],
+    api_key_id: Annotated[Optional[str], typer.Option(..., help="API Key ID")] = None,
+    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
+    role: Annotated[str, typer.Option(..., help="Role to assign to this participant")] = "user"
+):
+    """
+    Watch logs from the developer feed in the specified room.
+    """
+   
+    account_client = await get_client()
+    try:
+        # Resolve project ID (or fetch from the active project 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 project's API key
+        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+
+        # Build a 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 a developer client from the room client
+
+            # Define how to handle the incoming log events
+            def handle_log(type: str, data: dict):
+                # You can customize this print to suit your needs
+                print(f"[magenta]{type}[/magenta]: {json.dumps(data, indent=2)}")
+
+            # Attach our handler to the "log" event
+            client.developer.on("log", handle_log)
+
+            # Enable watching
+            await client.developer.enable()
+            print("[bold cyan]watching enabled. Press Ctrl+C to stop.[/bold cyan]")
+
+            try:
+                # Block forever, until Ctrl+C
+                while True:
+                    await asyncio.sleep(10)
+            except KeyboardInterrupt:
+                print("[bold red]Stopping watch...[/bold red]")
+            finally:
+                # Disable watching before exiting
+                await client.developer.disable()
+
+    finally:
+        await account_client.close()

meshagent/cli/helper.py

@@ -0,0 +1,113 @@
+from meshagent.cli import async_typer
+import typer
+from meshagent.api.helpers import meshagent_base_url
+from meshagent.api.accounts_client import AccountsClient
+
+from rich.console import Console
+from rich.table import Table
+
+from pydantic import BaseModel
+
+from meshagent.cli import auth_async 
+from pathlib import Path
+from typing import Optional
+
+SETTINGS_FILE = Path.home() / ".meshagent" / "project.json"
+
+def _ensure_cache_dir():
+    SETTINGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+class Settings(BaseModel):
+    active_project: Optional[str] = None
+    active_api_keys: Optional[dict] = {}
+
+def _save_settings(s: Settings):
+    _ensure_cache_dir()
+    SETTINGS_FILE.write_text(s.model_dump_json())
+    
+def _load_settings():
+    _ensure_cache_dir()
+    if SETTINGS_FILE.exists():
+        return Settings.model_validate_json(SETTINGS_FILE.read_text())
+    
+    return Settings()
+
+async def get_active_project():
+    settings = _load_settings()
+    if settings == None:
+        return None
+    return settings.active_project
+
+
+async def set_active_project(project_id: str | None):
+    settings = _load_settings()
+    settings.active_project = project_id
+    _save_settings(settings)
+
+async def get_active_api_key(project_id: str):
+    settings = _load_settings()
+    if settings == None:
+        return None
+    return settings.active_api_keys[project_id]
+
+
+async def set_active_api_key(project_id: str, api_key_id: str | None):
+    settings = _load_settings()
+    settings.active_api_keys[project_id] = api_key_id
+    _save_settings(settings)
+
+
+app = async_typer.AsyncTyper()
+
+async def get_client():
+    access_token = await auth_async.get_access_token()
+    return AccountsClient(base_url=meshagent_base_url(), token=access_token)
+
+def print_json_table(records: list, *cols):
+    
+    if not records:
+        raise SystemExit("No rows to print")
+
+    # 2️⃣  --- build the table -------------------------------------------
+    table = Table(show_header=True, header_style="bold magenta")
+
+    if len(cols) > 0:
+        # use the keys of the first object as column order
+        for col in cols:
+            table.add_column(col.title())               # "id" → "Id"
+
+        for row in records:
+            table.add_row(*(str(row.get(col, "")) for col in cols))
+
+    else:
+        # use the keys of the first object as column order
+        for col in records[0]:
+            table.add_column(col.title())               # "id" → "Id"
+
+        for row in records:
+            table.add_row(*(str(row.get(col, "")) for col in records[0]))
+
+    # 3️⃣  --- render ------------------------------------------------------
+    Console().print(table)
+
+
+async def resolve_project_id(project_id: Optional[str] = None):
+    if project_id == None: 
+        project_id = await get_active_project()
+    
+    if project_id == None:
+        print("[red]Project ID not specified, activate a project or pass a project on the command line[/red]")
+        raise typer.Exit(code=1)
+    
+    return project_id
+    
+async def resolve_api_key(project_id: str, api_key_id: Optional[str] = None):
+    if api_key_id == None: 
+        api_key_id = await get_active_api_key(project_id=project_id)
+    
+    if api_key_id == None:
+        print("[red]API Key ID not specified, activate an api key or pass an api key id on the command line[/red]")
+        raise typer.Exit(code=1)
+    
+    return api_key_id
+