meshagent-cli 0.0.37__py3-none-any.whl → 0.0.38__py3-none-any.whl

meshagent/cli/__init__.py

@@ -1 +1,3 @@
-from .version import __version__
+from .version import __version__
+
+__all__ = [__version__]

meshagent/cli/agent.py

@@ -5,35 +5,61 @@ import json
 import asyncio
 
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
-from meshagent.api.services import send_webhook
-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 meshagent.api import (
+    RoomClient,
+    ParticipantToken,
+    WebSocketClientProtocol,
+    RoomException,
+)
+from meshagent.cli.helper import resolve_project_id, resolve_api_key
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id, resolve_token_jwt
+from meshagent.cli.helper import get_client, resolve_token_jwt
 
 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):
+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"]
+        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
+            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 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:
@@ -49,14 +75,13 @@ async def ask(*, project_id: str = None, room: Annotated[str, typer.Option()], a
                     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:
@@ -65,24 +90,37 @@ async def ask(*, project_id: str = None, room: Annotated[str, typer.Option()], a
         await account_client.close()
 
 
-
 @app.async_command("invoke-tool")
 async def invoke_tool(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     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,
-    
+    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.
@@ -92,14 +130,22 @@ async def invoke_tool(
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt)
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
         ) as client:
-            
             found = timeout == 0
             for i in range(timeout):
                 if found:
@@ -108,19 +154,20 @@ async def invoke_tool(
                 if i == 1:
                     print("[magenta]Waiting for toolkit...[/magenta]")
 
-                agents = await client.agents.list_toolkits(participant_id=participant_id)
+                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(
@@ -144,10 +191,10 @@ async def list_agents_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user"
+    role: str = "user",
 ):
     """
     List all agents available in the room.
@@ -156,28 +203,39 @@ async def list_agents_command(
     try:
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt)
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
         ) 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,
-                })
+                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()
 
@@ -187,11 +245,13 @@ async def list_toolkits_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     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
+    participant_id: Annotated[
+        Optional[str], typer.Option(..., help="Optional participant ID")
+    ] = None,
 ):
     """
     List all toolkits (and tools within them) available in the room.
@@ -200,40 +260,49 @@ async def list_toolkits_command(
     try:
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt)
+            protocol=WebSocketClientProtocol(
+                url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
+                token=jwt,
+            )
         ) 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
-                    ]
-                })
+                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/api_keys.py

@@ -1,39 +1,57 @@
 import typer
+import json
 from rich import print
+from typing import Annotated
 from meshagent.cli import async_typer
 from meshagent.cli.helper import get_client, print_json_table
-from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, set_active_api_key, resolve_api_key
+from meshagent.cli.helper import resolve_project_id, set_active_api_key
 
 app = async_typer.AsyncTyper()
 
 
 @app.async_command("list")
-async def list(*, project_id: str = None):
-
+async def list(
+    *,
+    project_id: str = None,
+    o: Annotated[
+        str,
+        typer.Option(
+            "--output",
+            "-o",
+            help="output format [json|table]",
+        ),
+    ] = "table",
+):
     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")
+        if o == "json":
+            sanitized_keys = [
+                {k: v for k, v in key.items() if k != "created_by"} for key in keys
+            ]
+            print(json.dumps({"api-keys": sanitized_keys}, indent=2))
+        else:
+            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)
+    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()
@@ -50,7 +68,7 @@ async def show(*, project_id: str = None, api_key_id: str):
         key = await client.decrypt_project_api_key(project_id=project_id, id=api_key_id)
 
         print(key["token"])
-    
+
     finally:
         await client.close()
 

meshagent/cli/auth.py

@@ -1,8 +1,8 @@
 import typer
 
 from meshagent.cli import async_typer
-from meshagent.cli import auth_async 
-from meshagent.cli.helper import set_active_project, get_active_project
+from meshagent.cli import auth_async
+from meshagent.cli.helper import get_active_project
 
 app = async_typer.AsyncTyper()
 
@@ -12,13 +12,18 @@ 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"')
+    if project_id is 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 logout():
     await auth_async.logout()
 
+
 @app.async_command("whoami")
 async def whoami():
     _, s = await auth_async.session()

meshagent/cli/auth_async.py

@@ -1,49 +1,67 @@
-import os, json, webbrowser, asyncio
+import os
+import json
+import webbrowser
+import 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._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.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im5memhyeWpoc3RjZXdkeWdvampzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzQ2MzU2MjgsImV4cCI6MjA1MDIxMTYyOH0.ujx9CIbYEvWbA77ogB1gg1Jrv3KtpB1rWh_LRRLpcow")
-CACHE_FILE    = Path.home() / ".meshagent" / "session.json"
+AUTH_URL = os.getenv("MESHAGENT_AUTH_URL", "https://infra.meshagent.com")
+AUTH_ANON_KEY = os.getenv(
+    "MESHAGENT_AUTH_ANON_KEY",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im5memhyeWpoc3RjZXdkeWdvampzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzQ2MzU2MjgsImV4cCI6MjA1MDIxMTYyOH0.ujx9CIbYEvWbA77ogB1gg1Jrv3KtpB1rWh_LRRLpcow",
+)
+CACHE_FILE = Path.home() / ".meshagent" / "session.json"
 REDIRECT_PORT = 8765
-REDIRECT_URL  = f"http://localhost:{REDIRECT_PORT}/callback"
+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}
+            flow_type="pkce",  # OAuth + PKCE :contentReference[oaicite:2]{index=2}
             auto_refresh_token=True,
             persist_session=False,
-            storage=AsyncMemoryStorage()
+            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)
-    }))
+    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()
@@ -68,8 +86,10 @@ async def _wait_for_code() -> str:
     finally:
         await runner.cleanup()
 
+
 # ---------- public API -------------------------------------------------------
 
+
 async def login():
     supa = await _client()
 
@@ -79,7 +99,7 @@ async def login():
             "provider": "google",
             "options": {"redirect_to": REDIRECT_URL},
         }
-    )                                                      # :contentReference[oaicite:3]{index=3}
+    )  # :contentReference[oaicite:3]{index=3}
     oauth_url = res.url
 
     # 2️⃣  Kick user to browser without blocking the loop
@@ -89,20 +109,22 @@ async def login():
     # 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})  # 
+    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
+        fresh = await supa.auth.get_session()  # returns a Session object
         _save(fresh)
     return supa, fresh
 
+
 async def logout():
     supa, s = await session()
     if s:
@@ -110,6 +132,7 @@ async def logout():
     CACHE_FILE.unlink(missing_ok=True)
     print("👋 Signed out")
 
+
 async def get_access_token():
     supa, fresh = await session()
     return fresh.access_token