meshagent-cli 0.0.17__tar.gz → 0.0.19__tar.gz

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.0.17
+Version: 0.0.19
 Summary: CLI for Meshagent
 License-Expression: LicenseRef-Proprietary
 Project-URL: Documentation, https://meshagent.com
@@ -10,9 +10,11 @@ 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
+Requires-Dist: meshagent-api~=0.0.19
+Requires-Dist: meshagent-agents~=0.0.19
+Requires-Dist: meshagent-tools~=0.0.19
+Requires-Dist: meshagent-mcp~=0.0.19
+Requires-Dist: supabase~=2.15.1
 
 ### Meshagent CLI
 

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/agent.py

@@ -1,15 +1,15 @@
-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.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.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id, resolve_token_jwt
 
 app = async_typer.AsyncTyper()
 
@@ -71,6 +71,7 @@ async def invoke_tool(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    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",
@@ -90,20 +91,13 @@ async def invoke_tool(
     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)
+        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=token.to_jwt(token=key))
+                                             token=jwt)
         ) as client:
             
             found = timeout == 0
@@ -150,6 +144,7 @@ async def list_agents_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    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"
@@ -161,20 +156,12 @@ 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)
-        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)
+        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=token.to_jwt(token=key))
+                                             token=jwt)
         ) as client:
             print("[bold green]Fetching list of agents...[/bold green]")
             agents = await client.agents.list_agents()
@@ -200,6 +187,7 @@ async def list_toolkits_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    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",
@@ -212,20 +200,12 @@ 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)
-        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)
+        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=token.to_jwt(token=key))
+                                             token=jwt)
         ) as client:
             print("[bold green]Fetching list of toolkits...[/bold green]")
             toolkits = await client.agents.list_toolkits(participant_id=participant_id)

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/api_keys.py

@@ -1,8 +1,7 @@
-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 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
 
 app = async_typer.AsyncTyper()

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/auth.py

@@ -1,11 +1,8 @@
 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 
+from meshagent.cli.helper import set_active_project, get_active_project
 
 app = async_typer.AsyncTyper()
 

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/cli_mcp.py

@@ -3,43 +3,40 @@ 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 import RoomClient, ParticipantToken, WebSocketClientProtocol, RoomException
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
+from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, resolve_api_key, resolve_token_jwt
+
+from meshagent.tools.hosting import RemoteToolkit, RemoteToolkitServer
+
+from meshagent.mcp import MCPToolkit
+from pathlib import Path
+
+from meshagent.api.services import ServiceHost
+import os
+
 
-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()]):
+async def sse(*, project_id: str = None, room: Annotated[str, typer.Option()], 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 = "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)
-
+        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=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=jwt)) as client:
             
             async with sse_client(url) as (read_stream, write_stream):
 
@@ -66,25 +63,16 @@ async def sse(*, project_id: str = None, room: Annotated[str, typer.Option()], a
 
 
 @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()]):
+async def stdio(*, project_id: str = None, room: Annotated[str, typer.Option()], 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 = "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)
+        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=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=jwt)) as client:
             
             async with stdio_client(StdioServerParameters(
                     command=command,  # Executable
@@ -111,3 +99,53 @@ async def stdio(*, project_id: str = None, room: Annotated[str, typer.Option()],
         print(f"[red]{e}[/red]")
     finally:
         await account_client.close()
+
+
+@app.async_command("stdio-service")
+async def stdio_host(*,  command: Annotated[str, typer.Option()], args: Annotated[Optional[str], typer.Option()] = "", host: Annotated[Optional[str], typer.Option()] = None, port: Annotated[Optional[int], typer.Option()] = None, webhook_secret: Annotated[Optional[str], typer.Option()] = None, path: Annotated[Optional[str], typer.Option()] = None):
+    account_client = await get_client()
+    try:
+      
+        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="mcp", session=session, tools=mcp_tools_response.tools)
+                
+                if port == None:
+
+                    port = int(os.getenv("MESHAGENT_PORT", "8080"))
+
+                if host == None:
+
+                    host = "localhost"
+
+                service_host = ServiceHost(
+                    host=host,
+                    port=port,
+                    webhook_secret=webhook_secret
+                )
+
+                if path == None:
+                    path = "/service"
+
+                print(f"[bold green]Starting service host on {host}:{port}{path}...[/bold green]")
+                @service_host.path(path=path)
+                class CustomToolkit(RemoteToolkit):
+                    def __init__(self):
+                        super().__init__(name=toolkit.name, tools=toolkit.tools, title=toolkit.title, description=toolkit.description)
+
+                
+                await service_host.run()
+
+
+    except RoomException as e:
+        print(f"[red]{e}[/red]")
+    finally:
+        await account_client.close()

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/helper.py

@@ -1,17 +1,18 @@
-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
 
+from meshagent.cli import auth_async 
+from meshagent.cli import async_typer
+from meshagent.api.helpers import meshagent_base_url
+from meshagent.api.accounts_client import AccountsClient
+from meshagent.api.participant_token import ParticipantToken
+
+import os
+
 SETTINGS_FILE = Path.home() / ".meshagent" / "project.json"
 
 def _ensure_cache_dir():
@@ -110,4 +111,44 @@ async def resolve_api_key(project_id: str, api_key_id: Optional[str] = None):
         raise typer.Exit(code=1)
     
     return api_key_id
-    
+    
+
+async def resolve_token_jwt(*, project_id: str, api_key_id: Optional[str] = None, token_path: Optional[str] = None, name: Optional[str] = None, role: Optional[str] = None, room: Optional[str]= None) -> str:
+    jwt = None
+    
+    if api_key_id == None:
+        
+        if token_path != None:
+
+            if token_path == None:
+
+                token_path = os.getenv("MESHAGENT_TOKEN_PATH", (Path.home() / ".meshagent" / "token").as_posix())
+
+            p = Path(token_path)
+            jwt = p.read_text().strip()
+        
+        else:
+
+            jwt = os.getenv("MESHAGENT_TOKEN", None)
+
+    if jwt == None:
+   
+        account_client = await get_client()
+        try:
+            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)
+
+            jwt = token.to_jwt(token=key)
+        finally:
+
+            await account_client.close()
+
+    return jwt

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/messaging.py

@@ -1,12 +1,13 @@
-from meshagent.cli import async_typer
 import typer
-from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key
 from rich import print
-from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
-from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from typing import Annotated, Optional
 import json
 
+from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key, resolve_token_jwt
+
 app = async_typer.AsyncTyper()
 
 
@@ -15,6 +16,7 @@ async def messaging_list_participants_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
     role: str = "user"
@@ -28,23 +30,13 @@ async def messaging_list_participants_command(
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
-        # Decrypt the API key
-        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
-
-        # Build 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)
+        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=token.to_jwt(token=key)
+                token=jwt
             )
         ) as client:
 
@@ -74,6 +66,7 @@ async def messaging_send_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
     role: str = "user",
@@ -89,23 +82,13 @@ async def messaging_send_command(
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
-        # Decrypt the API key
-        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
-
-        # Build 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)
+        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=token.to_jwt(token=key)
+                token=jwt
             )
         ) as client:
             # Create and enable messaging
@@ -142,6 +125,7 @@ async def messaging_broadcast_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option()],
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
     role: str = "user",
@@ -156,23 +140,13 @@ async def messaging_broadcast_command(
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
-        # Decrypt the API key
-        key = (await account_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
-
-        # Build 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)
+        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=token.to_jwt(token=key)
+                token=jwt
             )
         ) as client:
             # Create and enable messaging

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/participant_token.py

@@ -1,19 +1,20 @@
-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
-from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id
 from typing import Annotated, Optional
-
+from meshagent.api import RoomClient, ParticipantToken
+from meshagent.cli.helper import set_active_project, get_active_project, 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
+import pathlib
 
 app = async_typer.AsyncTyper()
 
 @app.async_command("generate")
-async def generate(*, project_id: str = None, room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option()], role: str = "agent"):
+async def generate(*, project_id: str = None, token_path: Annotated[str, typer.Option()], room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option()], role: str = "agent"):
     client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
+        api_key_id = await resolve_api_key(project_id=project_id, api_key_id=api_key_id)
 
         key = (await client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
 
@@ -27,7 +28,13 @@ async def generate(*, project_id: str = None, room: Annotated[str, typer.Option(
 
         token.add_room_grant(room)
 
-        print(token.to_jwt(token=key))
+        if token_path == None:
+
+            print(token.to_jwt(token=key))
+
+        else:
+
+            pathlib.Path(token_path).expanduser().resolve().write_text(token.to_jwt(token=key))
     
     finally:
         await client.close()

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/storage.py

@@ -1,4 +1,3 @@
-from meshagent.cli import async_typer
 import typer
 from typing import Annotated, Optional
 from rich import print
@@ -6,17 +5,15 @@ import os
 import fnmatch
 import glob
 import shutil
+
 from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
 from meshagent.api.room_server_client import StorageClient
-
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
-
-from meshagent.cli .helper import get_client, resolve_project_id, resolve_api_key
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key, resolve_token_jwt
 
 app = async_typer.AsyncTyper()
 
-
-
 def parse_path(path: str):
     """
     Parse a path and return a tuple (scheme, subpath).
@@ -53,6 +50,7 @@ async def storage_exists_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option(..., help="Room name")],
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option(..., help="API Key ID")] = None,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "user",
@@ -65,22 +63,14 @@ async def storage_exists_command(
     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)
 
+        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=token.to_jwt(token=key)
+                token=jwt
             )
         ) as client:
             
@@ -98,6 +88,7 @@ async def storage_cp_command(
     *,
     project_id: str = None,
     room: Annotated[str, typer.Option(..., help="Room name (if copying to/from remote)")],
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[str, typer.Option(..., help="API Key ID (if copying to/from remote)")],
     name: Annotated[str, typer.Option(..., help="Participant name (if copying to/from remote)")],
     role: str = "user",
@@ -124,30 +115,22 @@ async def storage_cp_command(
 
         # A helper to ensure we have a connected StorageClient if needed
         async def ensure_storage_client():
-            nonlocal account_client, client, storage_client, api_key_id
+            nonlocal account_client, client, storage_client, api_key_id, project_id
 
             if storage_client is not None:
                 return  # Already connected
 
             account_client = await get_client()
-            resolved_proj_id = await resolve_project_id(project_id=project_id)
+            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=resolved_proj_id, id=api_key_id))["token"]
-
-            token = ParticipantToken(
-                name=name,
-                project_id=resolved_proj_id,
-                api_key_id=api_key_id
-            )
-            token.add_role_grant(role=role)
-            token.add_room_grant(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]")
             client = RoomClient(
                 protocol=WebSocketClientProtocol(
                     url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                    token=token.to_jwt(token=key)
+                    token=jwt
                 )
             )
 
@@ -317,6 +300,7 @@ async def storage_show_command(
     *,
     project_id: Annotated[Optional[str], typer.Option(..., help="Project ID (if remote)")] = None,
     room: Annotated[Optional[str], typer.Option(..., help="Room name (if remote)")] = None,
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option(..., help="API Key ID (if remote)")] = None,
     name: Annotated[Optional[str], typer.Option(..., help="Participant name (if remote)")] = None,
     role: str = "user",
@@ -334,35 +318,27 @@ async def storage_show_command(
     storage_client = None
 
     async def ensure_storage_client():
-        nonlocal account_client, client, storage_client, api_key_id
+        nonlocal account_client, client, storage_client, api_key_id, project_id
 
         if storage_client is not None:
             return
 
-        if not room or not api_key_id or not name:
+        if not room:
             raise typer.BadParameter(
-                "To show a remote file, you must provide --room, --api-key-id, and --name."
+                "To show a remote file, you must provide --room"
             )
 
         account_client = await get_client()
-        resolved_proj_id = await resolve_project_id(project_id=project_id)
+        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=resolved_proj_id, id=api_key_id))["token"]
 
-        token = ParticipantToken(
-            name=name,
-            project_id=resolved_proj_id,
-            api_key_id=api_key_id
-        )
-        token.add_role_grant(role=role)
-        token.add_room_grant(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]")
         client = RoomClient(
             protocol=WebSocketClientProtocol(
                 url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                token=token.to_jwt(token=key)
+                token=jwt
             )
         )
 
@@ -400,6 +376,7 @@ async def storage_rm_command(
     *,
     project_id: Annotated[Optional[str], typer.Option(..., help="Project ID (if remote)")] = None,
     room: Annotated[Optional[str], typer.Option(..., help="Room name (if remote)")] = None,
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option(..., help="API Key ID (if remote)")] = None,
     name: Annotated[Optional[str], typer.Option(..., help="Participant name (if remote)")] = None,
     role: str = "user",
@@ -428,29 +405,20 @@ async def storage_rm_command(
             if storage_client is not None:
                 return  # Already set up
 
-            if not room or not api_key_id or not name:
+            if not room:
                 raise typer.BadParameter(
-                    "To remove a remote file or folder, you must provide --room, --api-key-id, and --name."
+                    "To remove a remote file or folder, you must provide --room"
                 )
 
             account_client = await get_client()
-            resolved_proj_id = await resolve_project_id(project_id=project_id)
-            api_key_id = resolve_api_key(resolved_proj_id, api_key_id)
-            key = (await account_client.decrypt_project_api_key(project_id=resolved_proj_id, id=api_key_id))["token"]
-
-            token = ParticipantToken(
-                name=name,
-                project_id=resolved_proj_id,
-                api_key_id=api_key_id
-            )
-            token.add_role_grant(role=role)
-            token.add_room_grant(room)
+            project_id = await resolve_project_id(project_id=project_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)
 
             print("[bold green]Connecting to room...[/bold green]")
             client = RoomClient(
                 protocol=WebSocketClientProtocol(
                     url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                    token=token.to_jwt(token=key)
+                    token=jwt
                 )
             )
 
@@ -593,6 +561,7 @@ async def storage_ls_command(
     *,
     project_id: Annotated[Optional[str], typer.Option(..., help="Project ID (if remote)")] = None,
     room: Annotated[Optional[str], typer.Option(..., help="Room name (if remote)")] = None,
+    token_path: Annotated[Optional[str], typer.Option()] = None, 
     api_key_id: Annotated[Optional[str], typer.Option(..., help="API Key ID (if remote)")] = None,
     name: Annotated[Optional[str], typer.Option(..., help="Participant name (if remote)")] = None,
     role: str = "user",
@@ -613,31 +582,24 @@ async def storage_ls_command(
 
     # --- Set up remote connection if needed ---
     async def ensure_storage_client():
-        nonlocal account_client, client, storage_client
+        nonlocal account_client, client, storage_client, project_id
         if storage_client is not None:
             return
 
-        if not room or not api_key_id or not name:
+        if not room:
             raise typer.BadParameter(
-                "To list a remote path, you must provide --room, --api-key-id, and --name."
+                "To list a remote path, you must provide --room"
             )
 
         account_client = await get_client()
-        resolved_proj_id = await resolve_project_id(project_id=project_id)
-        key = (await account_client.decrypt_project_api_key(project_id=resolved_proj_id, id=api_key_id))["token"]
-
-        token = ParticipantToken(
-            name=name,
-            project_id=resolved_proj_id,
-            api_key_id=api_key_id
-        )
-        token.add_role_grant(role=role)
-        token.add_room_grant(room)
+        project_id = await resolve_project_id(project_id=project_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)
         
         client = RoomClient(
             protocol=WebSocketClientProtocol(
                 url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
-                token=token.to_jwt(token=key)
+                token=jwt
             )
         )
         await client.__aenter__()

meshagent_cli-0.0.19/meshagent/cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.19"

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/webhook.py

@@ -1,10 +1,11 @@
-from meshagent.cli import async_typer
 import typer
-from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
 from rich import print
 import json
 from typing import Annotated, List, Optional
 
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
+
 app = async_typer.AsyncTyper()
 
 # ---------------------------------------------------------------------------

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.0.17
+Version: 0.0.19
 Summary: CLI for Meshagent
 License-Expression: LicenseRef-Proprietary
 Project-URL: Documentation, https://meshagent.com
@@ -10,9 +10,11 @@ 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
+Requires-Dist: meshagent-api~=0.0.19
+Requires-Dist: meshagent-agents~=0.0.19
+Requires-Dist: meshagent-tools~=0.0.19
+Requires-Dist: meshagent-mcp~=0.0.19
+Requires-Dist: supabase~=2.15.1
 
 ### Meshagent CLI
 

meshagent_cli-0.0.19/meshagent_cli.egg-info/requires.txt

@@ -0,0 +1,7 @@
+typer~=0.15.3
+pydantic-yaml~=1.4.0
+meshagent-api~=0.0.19
+meshagent-agents~=0.0.19
+meshagent-tools~=0.0.19
+meshagent-mcp~=0.0.19
+supabase~=2.15.1

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/pyproject.toml

@@ -11,9 +11,11 @@ keywords = []
 dependencies = [
   "typer~=0.15.3",
   "pydantic-yaml~=1.4.0",
-  "meshagent-api~=0.0.17",
-  "meshagent-agents~=0.0.17",
-  "meshagent-tools~=0.0.17",
+  "meshagent-api~=0.0.19",
+  "meshagent-agents~=0.0.19",
+  "meshagent-tools~=0.0.19",
+  "meshagent-mcp~=0.0.19",
+  "supabase~=2.15.1",
 ]
 dynamic = ["version", "readme"]
 

meshagent_cli-0.0.17/meshagent/cli/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.17"

meshagent_cli-0.0.17/meshagent_cli.egg-info/requires.txt

@@ -1,5 +0,0 @@
-typer~=0.15.3
-pydantic-yaml~=1.4.0
-meshagent-api~=0.0.17
-meshagent-agents~=0.0.17
-meshagent-tools~=0.0.17

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/call.py

@@ -1,15 +1,15 @@
 
-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 import RoomClient, ParticipantToken, WebSocketClientProtocol, RoomException
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.api.services import send_webhook
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
+from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, resolve_api_key
 
 app = async_typer.AsyncTyper()
 

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/cli_secrets.py

@@ -1,12 +1,12 @@
 # --------------------------------------------------------------------------
 #  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.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
 from meshagent.api.accounts_client import PullSecret, KeysSecret, SecretLike   # or wherever you defined them
 
 # --------------------------------------------------------------------------

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/developer.py

@@ -1,12 +1,12 @@
 import asyncio
 import json
-from meshagent.cli import async_typer
 import typer
+from rich import print
+from typing import Annotated, Optional
+from meshagent.cli import async_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()
 

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/projects.py

@@ -1,7 +1,7 @@
-from meshagent.cli import async_typer
 import typer
-from meshagent.cli.helper import get_client, print_json_table, set_active_project
 from rich import print
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, set_active_project
 
 app = async_typer.AsyncTyper()
 

{meshagent_cli-0.0.17 → meshagent_cli-0.0.19}/meshagent/cli/services.py

@@ -1,16 +1,16 @@
 # ---------------------------------------------------------------------------
 #  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, List, Optional, Dict
 from datetime import datetime, timezone
 from pydantic_yaml import parse_yaml_raw_as, to_yaml_str
 from pydantic import PositiveInt
 import pydantic
 from typing import Literal
+from meshagent.cli import async_typer
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
 
 # Pydantic basemodels
 from meshagent.api.accounts_client import Service, Port