meshagent-cli 0.0.17__tar.gz

meshagent_cli-0.0.17/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: meshagent-cli
+Version: 0.0.17
+Summary: CLI for Meshagent
+License-Expression: LicenseRef-Proprietary
+Project-URL: Documentation, https://meshagent.com
+Project-URL: Website, https://meshagent.com
+Project-URL: Source, https://github.com/meshagent
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+Requires-Dist: typer~=0.15.3
+Requires-Dist: pydantic-yaml~=1.4.0
+Requires-Dist: meshagent-api~=0.0.17
+Requires-Dist: meshagent-agents~=0.0.17
+Requires-Dist: meshagent-tools~=0.0.17
+
+### Meshagent CLI
+
+
+
+
+
+

meshagent_cli-0.0.17/README.md

@@ -0,0 +1,7 @@
+### Meshagent CLI
+
+
+
+
+
+

meshagent_cli-0.0.17/meshagent/cli/agent.py

@@ -0,0 +1,259 @@
+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
+import json
+import asyncio
+import aiohttp
+from meshagent.api.services import send_webhook
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("ask")
+async def ask(*, 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 = "user", agent: Annotated[str, typer.Option()], input: Annotated[str, typer.Option()], timeout: Annotated[Optional[int], typer.Option(..., help="How long to wait for the agent if the agent is not in the room")] = 30):
+    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:
+            
+            found = timeout == 0
+            for i in range(30):
+                if found:
+                    break
+
+                if i == 1:
+                    print("[magenta]Waiting for agent...[/magenta]")
+
+                agents = await client.agents.list_agents()
+                await asyncio.sleep(1)
+
+                for a in agents:
+                    if a.name == agent:
+                        found = True
+                        break
+            
+            if not found:
+                print("[red]Timed out waiting for agent to join the room[/red]")
+                raise typer.Exit(1)
+
+
+            print("[magenta]Asking agent...[/magenta]")
+            
+            response = await client.agents.ask(agent=agent, arguments=json.loads(input))
+            print(json.dumps(response.json))
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()
+
+
+
+@app.async_command("invoke-tool")
+async def invoke_tool(
+    *,
+    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 = "user",
+    toolkit: Annotated[str, typer.Option(..., help="Toolkit name")],
+    tool: Annotated[str, typer.Option(..., help="Tool name")],
+    arguments: Annotated[str, typer.Option(..., help="JSON string with arguments for the tool")],
+    participant_id: Annotated[Optional[str], typer.Option(..., help="Optional participant ID to invoke the tool on")] = None,
+    on_behalf_of_id: Annotated[Optional[str], typer.Option(..., help="Optional 'on_behalf_of' participant ID")] = None,
+    caller_context: Annotated[Optional[str], typer.Option(..., help="Optional JSON for caller context")] = None,
+    timeout: Annotated[Optional[int], typer.Option(..., help="How long to wait for the toolkit if the toolkit is not in the room")] = 30,
+    
+):
+    """
+    Invoke a specific tool from a given toolkit with arguments.
+    """
+    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:
+            
+            found = timeout == 0
+            for i in range(timeout):
+                if found:
+                    break
+
+                if i == 1:
+                    print("[magenta]Waiting for toolkit...[/magenta]")
+
+                agents = await client.agents.list_toolkits(participant_id=participant_id)
+                await asyncio.sleep(1)
+
+                for a in agents:
+                    if a.name == toolkit:
+                        found = True
+                        break
+            
+            if not found:
+                print("[red]Timed out waiting for toolkit to join the room[/red]")
+                raise typer.Exit(1)
+
+
+            print("[bold green]Invoking tool...[/bold green]")
+            parsed_context = json.loads(caller_context) if caller_context else None
+            response = await client.agents.invoke_tool(
+                toolkit=toolkit,
+                tool=tool,
+                arguments=json.loads(arguments),
+                participant_id=participant_id,
+                on_behalf_of_id=on_behalf_of_id,
+                caller_context=parsed_context,
+            )
+            # The response is presumably a dictionary or similar
+            print(response.to_json())
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list-agents")
+async def list_agents_command(
+    *,
+    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 = "user"
+):
+    """
+    List all agents available in the room.
+    """
+    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:
+            print("[bold green]Fetching list of agents...[/bold green]")
+            agents = await client.agents.list_agents()
+            # Format the output as JSON
+            output = []
+            for agent in agents:
+                output.append({
+                    "name": agent.name,
+                    "title": agent.title,
+                    "description": agent.description,
+                    "requires": [r.to_json() for r in agent.requires],
+                    "supports_tools": agent.supports_tools,
+                    "labels": agent.labels,
+                })
+            print(json.dumps(output, indent=2))
+    
+    finally:
+        await account_client.close()
+
+
+@app.async_command("list-toolkits")
+async def list_toolkits_command(
+    *,
+    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 = "user",
+    participant_id: Annotated[Optional[str], typer.Option(..., help="Optional participant ID")] = None
+):
+    """
+    List all toolkits (and tools within them) available in the room.
+    """
+    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:
+            print("[bold green]Fetching list of toolkits...[/bold green]")
+            toolkits = await client.agents.list_toolkits(participant_id=participant_id)
+            
+            # Format and output as JSON
+            output = []
+            for tk in toolkits:
+                output.append({
+                    "name": tk.name,
+                    "title": tk.title,
+                    "description": tk.description,
+                    "thumbnail_url": tk.thumbnail_url,
+                    "tools": [
+                        {
+                            "name": tool.name,
+                            "title": tool.title,
+                            "description": tool.description,
+                            "input_schema": tool.input_schema,
+                            "thumbnail_url": tool.thumbnail_url,
+                            "defs": tool.defs,
+                            "supports_context": tool.supports_context
+                        }
+                        for tool in tk.tools
+                    ]
+                })
+            print(json.dumps(output, indent=2))
+    
+    finally:
+        await account_client.close()
+
+

meshagent_cli-0.0.17/meshagent/cli/api_keys.py

@@ -0,0 +1,74 @@
+from meshagent.cli import async_typer
+import typer
+from meshagent.cli.helper import get_client, print_json_table
+from rich import print
+from typing import Optional
+from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, set_active_api_key, resolve_api_key
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("list")
+async def list(*, project_id: str = None):
+
+    project_id = await resolve_project_id(project_id=project_id)
+
+    client = await get_client()
+    keys = (await client.list_project_api_keys(project_id=project_id))["keys"]
+    if len(keys) > 0:
+        print_json_table(keys, "id", "name", "description")
+    else:
+        print("There are not currently any API keys in the project")
+    await client.close()
+
+@app.async_command("create")
+async def create(*, project_id: str = None, name: str, description: str = ""):
+
+    project_id = await resolve_project_id(project_id=project_id)
+
+    client = await get_client()
+    api_key = await client.create_project_api_key(project_id=project_id, name=name, description=description)
+    print(api_key["token"])
+    await client.close()
+
+
+@app.async_command("delete")
+async def delete(*, project_id: str = None, id: str):
+
+    project_id = await resolve_project_id(project_id=project_id)
+
+    client = await get_client()
+    await client.delete_project_api_key(project_id=project_id, id=id)
+    await client.close()
+
+
+@app.async_command("show")
+async def show(*, project_id: str = None, api_key_id: str):
+    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)
+
+        print(key["token"])
+    
+    finally:
+        await client.close()
+
+
+@app.async_command("activate")
+async def activate(api_key_id: str, project_id: str = None,):
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+        response = await client.list_project_api_keys(project_id=project_id)
+        api_keys = response["keys"]
+        for api_key in api_keys:
+            if api_key["id"] == api_key_id:
+                await set_active_api_key(project_id=project_id, api_key_id=api_key_id)
+                return
+
+        print(f"[red]Invalid api key id or project id: {project_id}[/red]")
+        raise typer.Exit(code=1)
+    finally:
+        await client.close()

meshagent_cli-0.0.17/meshagent/cli/async_typer.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+from functools import partial, wraps
+from typing import Any, Callable
+
+from typer import Typer
+
+
+class AsyncTyper(Typer):
+    @staticmethod
+    def maybe_run_async(decorator: Callable, func: Callable) -> Any:
+        if inspect.iscoroutinefunction(func):
+
+            @wraps(func)
+            def runner(*args: Any, **kwargs: Any) -> Any:
+                return asyncio.run(func(*args, **kwargs))
+
+            decorator(runner)
+        else:
+            decorator(func)
+        return func
+
+    def callback(self, *args: Any, **kwargs: Any) -> Any:
+        decorator = super().callback(*args, **kwargs)
+        return partial(self.maybe_run_async, decorator)
+
+    def async_command(self, *args: Any, **kwargs: Any) -> Any:
+        decorator = super().command(*args, **kwargs)
+        return partial(self.maybe_run_async, decorator)

meshagent_cli-0.0.17/meshagent/cli/auth.py

@@ -0,0 +1,28 @@
+import typer
+from meshagent.api.accounts_client import AccountsClient
+
+import os
+from .helper import set_active_project, get_active_project
+
+from meshagent.cli import async_typer
+from meshagent.cli import auth_async 
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("login")
+async def login():
+    await auth_async.login()
+
+    project_id = await get_active_project()
+    if project_id == None:
+        print('You have been logged in, but you haven''t activated a project yet, list your projects with "meshagent project list" and then activate one with "meshagent project activate PROJECT_ID"')
+
+@app.async_command("logout")
+async def login():
+    await auth_async.logout()
+
+@app.async_command("whoami")
+async def whoami():
+    _, s = await auth_async.session()
+    typer.echo(s.user.email if s else "Not logged in")

meshagent_cli-0.0.17/meshagent/cli/auth_async.py

@@ -0,0 +1,115 @@
+import os, json, webbrowser, asyncio
+from pathlib import Path
+from aiohttp import web
+from supabase._async.client import AsyncClient, create_client   # async flavour :contentReference[oaicite:1]{index=1}
+from supabase.lib.client_options import ClientOptions
+from gotrue import AsyncMemoryStorage
+
+AUTH_URL  = os.getenv("MESHAGENT_AUTH_URL", "https://infra.meshagent.com")
+AUTH_ANON_KEY  = os.getenv("MESHAGENT_AUTH_ANON_KEY", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImZqZGh5bWhhZ3BwZ2drYWJ6bGFmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzYzMTYyOTQsImV4cCI6MjA1MTg5MjI5NH0.8AuzzNcCuEaHQ-gjqHxBmsN1YrtM-TpL1_W-kxzooNs")
+CACHE_FILE    = Path.home() / ".meshagent" / "session.json"
+REDIRECT_PORT = 8765
+REDIRECT_URL  = f"http://localhost:{REDIRECT_PORT}/callback"
+
+# ---------- helpers ----------------------------------------------------------
+
+def _ensure_cache_dir():
+    CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+async def _client() -> AsyncClient:
+    return await create_client(
+        AUTH_URL,
+        AUTH_ANON_KEY,
+        options=ClientOptions(
+            flow_type="pkce",          # OAuth + PKCE :contentReference[oaicite:2]{index=2}
+            auto_refresh_token=True,
+            persist_session=False,
+            storage=AsyncMemoryStorage()
+        ),
+    )
+
+def _save(s):
+    _ensure_cache_dir()
+    CACHE_FILE.write_text(json.dumps({
+        "access_token": s.access_token,
+        "refresh_token": s.refresh_token,
+        "expires_at": s.expires_at,   # int (seconds since epoch)
+    }))
+
+    
+def _load():
+    _ensure_cache_dir()
+    if CACHE_FILE.exists():
+        return json.loads(CACHE_FILE.read_text())
+
+# ---------- local HTTP callback ---------------------------------------------
+
+async def _wait_for_code() -> str:
+    """Spin up a one-shot aiohttp server and await ?code=…"""
+    app = web.Application()
+    code_fut: asyncio.Future[str] = asyncio.get_event_loop().create_future()
+
+    async def callback(request):
+        code = request.query.get("code")
+        if code:
+            if not code_fut.done():
+                code_fut.set_result(code)
+            return web.Response(text="You may close this tab.")
+        return web.Response(status=400)
+
+    app.add_routes([web.get("/callback", callback)])
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, "localhost", REDIRECT_PORT)
+    await site.start()
+
+    try:
+        return await code_fut
+    finally:
+        await runner.cleanup()
+
+# ---------- public API -------------------------------------------------------
+
+async def login():
+    supa = await _client()
+
+    # 1️⃣  Build provider URL – async now
+    res = await supa.auth.sign_in_with_oauth(
+        {
+            "provider": "google",
+            "options": {"redirect_to": REDIRECT_URL},
+        }
+    )                                                      # :contentReference[oaicite:3]{index=3}
+    oauth_url = res.url
+
+    # 2️⃣  Kick user to browser without blocking the loop
+    await asyncio.to_thread(webbrowser.open, oauth_url)
+    print(f"Waiting for Google OAuth redirect on {oauth_url}…")
+
+    # 3️⃣  Await the auth code, then exchange for tokens
+    auth_code = await _wait_for_code()
+    print("Got code, exchanging…")
+    sess = await supa.auth.exchange_code_for_session({"auth_code": auth_code})  # 
+    _save(sess.session)
+    print("✅ Logged in as", sess.user.email)
+
+async def session():
+    supa = await _client()
+    cached = _load()
+    fresh = None
+    if cached:
+        await supa.auth.set_session(cached["access_token"], cached["refresh_token"])
+        fresh = await supa.auth.get_session()          # returns a Session object
+        _save(fresh)
+    return supa, fresh
+
+async def logout():
+    supa, s = await session()
+    if s:
+        await supa.auth.sign_out()
+    CACHE_FILE.unlink(missing_ok=True)
+    print("👋 Signed out")
+
+async def get_access_token():
+    supa, fresh = await session()
+    return fresh.access_token

meshagent_cli-0.0.17/meshagent/cli/call.py

@@ -0,0 +1,127 @@
+
+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
+import json
+import aiohttp
+from meshagent.api.services import send_webhook
+
+app = async_typer.AsyncTyper()
+
+from urllib.parse import urlparse
+from pathlib import PurePath
+import socket
+import ipaddress
+
+PRIVATE_NETS = (
+    ipaddress.ip_network("10.0.0.0/8"),
+    ipaddress.ip_network("172.16.0.0/12"),
+    ipaddress.ip_network("192.168.0.0/16"),
+    ipaddress.ip_network("169.254.0.0/16"),      # IPv4 link-local
+    ipaddress.ip_network("fc00::/7"),            # IPv6 unique-local
+    ipaddress.ip_network("fe80::/10"),           # IPv6 link-local
+)
+
+
+def is_local_url(url: str) -> bool:
+
+    """
+    Return True if *url* points to the local machine or a private-LAN host.
+    """
+    # 1. Handle bare paths and file://
+    if "://" not in url:
+        return PurePath(url).is_absolute() or not ("/" in url or "\\" in url)
+    parsed = urlparse(url)
+    if parsed.scheme == "file":
+        return True
+
+    # 2. Quick loop-back check on hostname literal
+    hostname = parsed.hostname
+    if hostname in {"localhost", None}:          # None ⇒ something like "http:///path"
+        return True
+
+    try:
+        # Accept both direct IP literals and DNS names
+        addr_info = socket.getaddrinfo(hostname, None)
+    except socket.gaierror:
+        return False        # Unresolvable host ⇒ treat as non-local (or raise)
+
+    for *_, sockaddr in addr_info:
+        ip_str = sockaddr[0]
+        ip = ipaddress.ip_address(ip_str)
+
+        if ip.is_loopback:
+            return True
+        if any(ip in net for net in PRIVATE_NETS):
+            return True
+
+
+@app.async_command("schema")
+@app.async_command("tool")
+@app.async_command("agent")
+async def make_call(
+    *,
+    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 = "agent",
+    local: Optional[bool] = None,
+    agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
+    url: Annotated[str, typer.Option(..., help="URL the agent should call")],
+    arguments: Annotated[str, typer.Option(..., help="JSON string with arguments for the call")] = {}
+):
+    """
+    Instruct an agent to 'call' a given URL with specific arguments.
+    """
+    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)
+
+        if local == None:
+            local = is_local_url(url)
+        
+        if local:
+            async with aiohttp.ClientSession() as session:
+                 
+                event="room.call"
+                data={
+                    "room_url" : websocket_room_url(room_name=room),
+                    "room_name" : room,
+                    "token" : token.to_jwt(token=key),
+                    "arguments" : arguments,
+                }
+                 
+                await send_webhook(session=session, url=url, event=event, data=data, secret=None)
+        else:
+            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:
+                print("[bold green]Making agent call...[/bold green]")
+                await client.agents.make_call(
+                    name=agent_name,
+                    url=url,
+                    arguments=json.loads(arguments)
+                )
+                print("[bold cyan]Call request sent successfully.[/bold cyan]")
+        
+    finally:
+        await account_client.close()