meshagent-cli 0.0.29__tar.gz → 0.0.31__tar.gz

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.0.29
+Version: 0.0.31
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -10,11 +10,12 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: typer~=0.15.3
 Requires-Dist: pydantic-yaml~=1.4.0
-Requires-Dist: meshagent-api~=0.0.29
-Requires-Dist: meshagent-agents~=0.0.29
-Requires-Dist: meshagent-tools~=0.0.29
-Requires-Dist: meshagent-mcp~=0.0.29
+Requires-Dist: meshagent-api~=0.0.31
+Requires-Dist: meshagent-agents~=0.0.31
+Requires-Dist: meshagent-tools~=0.0.31
+Requires-Dist: meshagent-mcp~=0.0.31
 Requires-Dist: supabase~=2.15.1
+Requires-Dist: fastmcp~=2.8.1
 
 ### Meshagent CLI
 

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/api_keys.py

@@ -56,16 +56,72 @@ async def show(*, project_id: str = None, api_key_id: str):
 
 
 @app.async_command("activate")
-async def activate(api_key_id: str, project_id: str = None,):
+async def activate(
+    api_key_id: str | None = typer.Argument(None),
+    project_id: str = None,
+    interactive: bool = typer.Option(
+        False,
+        "-i",
+        "--interactive",
+        help="Interactively select or create an api key",
+    ),
+):
     client = await get_client()
     try:
         project_id = await resolve_project_id(project_id)
+        if interactive:
+            response = await client.list_project_api_keys(project_id=project_id)
+            api_keys = response["keys"]
+
+            if not api_keys:
+                if typer.confirm(
+                    "There are no API keys. Would you like to create one?",
+                    default=True,
+                ):
+                    name = typer.prompt("API key name")
+                    created = await client.create_project_api_key(
+                        project_id=project_id,
+                        name=name,
+                        description="",
+                    )
+                    api_key_id = created["id"]
+                else:
+                    raise typer.Exit(code=0)
+            else:
+                for idx, key in enumerate(api_keys, start=1):
+                    print(f"[{idx}] {key['name']} ({key['id']})")
+                new_key_index = len(api_keys) + 1
+                print(f"[{new_key_index}] Create a new api key")
+                exit_index = new_key_index + 1
+                print(f"[{exit_index}] Exit")
+
+                choice = typer.prompt("Select an api key", type=int)
+                if choice == exit_index:
+                    return
+                elif choice == new_key_index:
+                    name = typer.prompt("API key name")
+                    created = await client.create_project_api_key(
+                        project_id=project_id,
+                        name=name,
+                        description="",
+                    )
+                    api_key_id = created["id"]
+                elif 1 <= choice <= len(api_keys):
+                    api_key_id = api_keys[choice - 1]["id"]
+                else:
+                    print("[red]Invalid selection[/red]")
+                    raise typer.Exit(code=1)
+
+        if api_key_id is None and not interactive:
+            print("[red]api_key_id required[/red]")
+            raise typer.Exit(code=1)
+
         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
+                return api_key_id
 
         print(f"[red]Invalid api key id or project id: {project_id}[/red]")
         raise typer.Exit(code=1)

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/auth.py

@@ -16,7 +16,7 @@ async def login():
         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():
+async def logout():
     await auth_async.logout()
 
 @app.async_command("whoami")

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/call.py

@@ -62,8 +62,9 @@ def is_local_url(url: str) -> bool:
 
 
 @app.async_command("schema")
-@app.async_command("tool")
+@app.async_command("toolkit")
 @app.async_command("agent")
+@app.async_command("tool")
 async def make_call(
     *,
     project_id: str = None,

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/cli.py

@@ -1,4 +1,5 @@
 import typer
+import asyncio
 
 from meshagent.cli import auth
 from meshagent.cli import api_keys
@@ -16,6 +17,7 @@ from meshagent.cli import call
 from meshagent.cli import cli_mcp
 from meshagent.cli import chatbot
 from meshagent.cli import voicebot
+from meshagent.cli import tty
 
 app = typer.Typer()
 app.add_typer(call.app, name="call")
@@ -34,6 +36,28 @@ app.add_typer(cli_secrets.app, name="secret")
 app.add_typer(cli_mcp.app, name="mcp")
 app.add_typer(chatbot.app, name="chatbot")
 app.add_typer(voicebot.app, name="voicebot")
+app.add_typer(tty.app, name="tty")
+
+def _run_async(coro):
+    asyncio.run(coro)
+
+@app.command("setup")
+def setup_command():
+    """Perform initial login and project/api key activation."""
+
+    async def runner():
+        await auth.login()
+        print("Activate a project...")
+        project_id = await projects.activate(None, interactive=True)
+        if project_id is None:
+            print("You have choosen to not activate a project. Exiting.")
+        if project_id is not None:
+            print("Activate an api-key...")
+            api_key_id = await api_keys.activate(None, interactive=True)
+            if api_key_id is None:
+                print("You have choosen to not activate an api-key. Exiting.")
+
+    _run_async(runner())
 
 if __name__ == "__main__":
     app()

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/cli_mcp.py

@@ -22,7 +22,6 @@ from meshagent.api.services import ServiceHost
 import os
 
 from meshagent.cli.services import _kv_to_dict
-
 import shlex
 
 app = async_typer.AsyncTyper()
@@ -107,10 +106,55 @@ async def stdio(*, project_id: str = None, room: Annotated[str, typer.Option()],
     finally:
         await account_client.close()
 
+@app.async_command("http-proxy")
+async def stdio_host(*, command: Annotated[str, typer.Option()], host: Annotated[Optional[str], typer.Option()] = None, port: Annotated[Optional[int], typer.Option()] = None, path: Annotated[Optional[str], typer.Option()] = None, name: Annotated[Optional[str], typer.Option()] = None, env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = []):
 
-@app.async_command("stdio-service")
-async def stdio_host(*,  command: Annotated[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, toolkit_name: Annotated[Optional[str], typer.Option()] = None, env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = []):
+    from fastmcp import FastMCP, Client
+    from fastmcp.client.transports import StdioTransport
+
+    parsed_command = shlex.split(command)
+    
+    # Create a client that connects to the original server
+    proxy_client = Client(
+        transport = StdioTransport(parsed_command[0], parsed_command[1:], _kv_to_dict(env)),
+    )
+
+    if name == None:
+        name = "Stdio-to-Streamable Http Proxy"
+
+    # Create a proxy server that connects to the client and exposes its capabilities
+    proxy = FastMCP.as_proxy(proxy_client, name=name)
+    if path == None:
+        path = "/mcp"
+    
+    await proxy.run_async(transport='streamable-http', host=host, port=port, path=path)
+
+
+@app.async_command("sse-proxy")
+async def stdio_host(*, command: Annotated[str, typer.Option()], host: Annotated[Optional[str], typer.Option()] = None, port: Annotated[Optional[int], typer.Option()] = None, path: Annotated[Optional[str], typer.Option()] = None, name: Annotated[Optional[str], typer.Option()] = None, env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = []):
+
+    from fastmcp import FastMCP, Client
+    from fastmcp.client.transports import StdioTransport
+
+    parsed_command = shlex.split(command)
     
+    # Create a client that connects to the original server
+    proxy_client = Client(
+        transport = StdioTransport(parsed_command[0], parsed_command[1:], _kv_to_dict(env)),
+    )
+
+    if name == None:
+        name = "Stdio-to-SSE Proxy"
+
+    # Create a proxy server that connects to the client and exposes its capabilities
+    proxy = FastMCP.as_proxy(proxy_client, name=name)
+    if path == None:
+        path = "/sse"
+    
+    await proxy.run_async(transport='sse', host=host, port=port, path=path)
+
+@app.async_command("stdio-service")
+async def stdio_host(*,  command: Annotated[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, toolkit_name: Annotated[Optional[str], typer.Option()] = None, env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = []):
     try:
         
         parsed_command = shlex.split(command)

meshagent_cli-0.0.31/meshagent/cli/projects.py

@@ -0,0 +1,98 @@
+import typer
+from rich import print
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    print_json_table,
+    set_active_project,
+    get_active_project,
+)
+
+app = async_typer.AsyncTyper()
+
+
+@app.async_command("create")
+async def create(name: str):
+    client = await get_client()
+    try:
+        result = await client.create_project(name)
+        print(f"[green]Project created:[/] {result["id"]}")
+    finally:
+        await client.close()
+
+@app.async_command("list")
+async def list():
+    client = await get_client()
+    projects = await client.list_projects()
+    active_project = await get_active_project()
+    for project in projects["projects"]:
+        if project["id"] == active_project:
+            project["name"] = "*" + project["name"]
+
+    print_json_table(projects["projects"], "id", "name")
+    await client.close()
+
+@app.async_command("activate")
+async def activate(
+    project_id: str | None = typer.Argument(None),
+    interactive: bool = typer.Option(
+        False,
+        "-i",
+        "--interactive",
+        help="Interactively select or create a project",
+    ),
+):
+    client = await get_client()
+    try:
+        if interactive:
+            response = await client.list_projects()
+            projects = response["projects"]
+
+            if not projects:
+                if typer.confirm(
+                    "There are no projects. Would you like to create one?",
+                    default=True,
+                ):
+                    name = typer.prompt("Project name")
+                    created = await client.create_project(name)
+                    project_id = created["id"]
+                else:
+                    raise typer.Exit(code=0)
+            else:
+                for idx, proj in enumerate(projects, start=1):
+                    print(f"[{idx}] {proj['name']} ({proj['id']})")
+                new_project_index = len(projects) + 1
+                print(f"[{new_project_index}] Create a new project")
+                exit_index = new_project_index + 1
+                print(f"[{exit_index}] Exit")
+
+                choice = typer.prompt("Select a project", type=int)
+                if choice == exit_index:
+                    return
+                elif choice == new_project_index:
+                    name = typer.prompt("Project name")
+                    # TODO: validate name
+                    created = await client.create_project(name)
+                    project_id = created["id"]
+                elif 1 <= choice <= len(projects):
+                    project_id = projects[choice - 1]["id"]
+                else:
+                    print("[red]Invalid selection[/red]")
+                    raise typer.Exit(code=1)
+
+        if project_id is None and not interactive:
+            print("[red]project_id required[/red]")
+            raise typer.Exit(code=1)
+
+        if project_id is not None:
+            projects = (await client.list_projects())["projects"]
+            for project in projects:
+                if project["id"] == project_id:
+                    await set_active_project(project_id=project_id)
+                    return project_id
+
+            print(f"[red]Invalid project id: {project_id}[/red]")
+            raise typer.Exit(code=1)
+    finally:
+        await client.close()
+

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/services.py

@@ -15,6 +15,7 @@ from meshagent.cli.helper import get_client, print_json_table, resolve_project_i
 from meshagent.api import ParticipantToken, RoomClient, WebSocketClientProtocol, websocket_protocol, websocket_room_url, meshagent_base_url
 # Pydantic basemodels
 from meshagent.api.accounts_client import Service, Port
+from meshagent.cloud.accounts import Services
 
 app = async_typer.AsyncTyper()
 
@@ -38,13 +39,14 @@ class PortSpec(pydantic.BaseModel):
     """
     CLI schema for --port.
     Example:
-        --port num=8080 type=webserver liveness=/health path=path
+        --port num=8080 type=webserver liveness=/health path=/agent participant_name=myname
     """
 
     num: PositiveInt
     type: Literal["mcp.sse", "meshagent.callable", "http", "tcp"]
     liveness: str | None = None
     participant_name: str | None = None
+    path: str | None = None
 
 
 def _parse_port_spec(spec: str) -> PortSpec:
@@ -76,7 +78,7 @@ async def service_create(
     project_id: str = None,
     name: Annotated[str, typer.Option(help="Friendly service name")],
     image: Annotated[str, typer.Option(help="Container image reference")],
-    role: Annotated[str, typer.Option(help="Service role (agent|tool)")],
+    role: Annotated[str, typer.Option(help="Service role (agent|tool)")] = None,
     pull_secret: Annotated[
         Optional[str],
         typer.Option("--pull-secret", help="Secret ID for registry"),
@@ -99,10 +101,10 @@ async def service_create(
             "-p",
             help=(
                 "Repeatable. Example:\n"
-                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health"'
+                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health path=/agent participant_name=myname"'
             ),
         ),
-    ] = [],
+    ] = ...,
 ):
     """Create a service attached to the project."""
     client = await get_client()
@@ -117,6 +119,7 @@ async def service_create(
                 type=ps.type,
                 liveness_path=ps.liveness,
                 participant_name=ps.participant_name,
+                path=ps.path,
             )
             for ps in port_specs
         } or None
@@ -159,7 +162,7 @@ async def service_test(
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     room: Annotated[str, typer.Option(help="A room name to test the service in (must not be currently running)")],
     name: Annotated[str, typer.Option(help="Friendly service name")],
-    role: Annotated[str, typer.Option(help="Service role (agent|tool)")],
+    role: Annotated[str, typer.Option(help="Service role (agent|tool)")] = None,
     image: Annotated[str, typer.Option(help="Container image reference")],
     pull_secret: Annotated[
         Optional[str],
@@ -183,10 +186,10 @@ async def service_test(
             "-p",
             help=(
                 "Repeatable. Example:\n"
-                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health"'
+                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health path=/agent participant_name=myname"'
             ),
         ),
-    ] = [],
+    ] = ...,
     timeout: Annotated[
         Optional[int],
         typer.Option("--timeout", help="The maximum time that this room should run (default 1hr)"),
@@ -195,7 +198,7 @@ async def service_test(
     
 
     """Create a service attached to the project."""
-    client = await get_client()
+    my_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id)
 
@@ -209,6 +212,7 @@ async def service_test(
                 type=ps.type,
                 liveness_path=ps.liveness,
                 participant_name=ps.participant_name,
+                path=ps.path,
             )
             for ps in port_specs
         } or None
@@ -245,7 +249,7 @@ async def service_test(
             
             print("[bold green]Connecting to room...[/bold green]")
 
-            key = (await client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+            key = (await my_client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
 
             async with RoomClient(
                 protocol=WebSocketClientProtocol(
@@ -254,11 +258,7 @@ async def service_test(
                 )
             ) as client:
                 
-                print(f"[green]Started room: {room}[/green]")
-                try:
-                    await client.protocol.wait_for_close()
-                except KeyboardInterrupt:
-                    pass
+                print(f"[green]Your test room '{room}' has been started. It will time out after a few minutes if you do not join it.[/green]")
 
             
         except ClientResponseError as exc:
@@ -269,7 +269,7 @@ async def service_test(
 
     
     finally:
-        await client.close()
+        await my_client.close()
 
 
 
@@ -292,7 +292,7 @@ async def service_show(
 
 
 @app.async_command("list")
-async def service_list(*, project_id: str = None):
+async def service_list(*, project_id: str = None, o: Annotated[str, typer.Option(help="output format [json|table]")]):
     """List all services for the project."""
     client = await get_client()
     try:
@@ -300,18 +300,16 @@ async def service_list(*, project_id: str = None):
         services: list[Service] = await client.list_services(
             project_id=project_id
         )  # → List[Service]
-        print_json_table(
-            [svc.model_dump(mode="json") for svc in services],
-            "id",
-            "name",
-            "role",
-            "image",
-            "command",
-            "room_storage_path",
-            "pull_secret",
-            "environment_secrets",
-            "ports",
-        )
+
+        if o == "json":
+            print(Services(services=services).model_dump_json(indent=2))
+        else:
+            print_json_table(
+                [svc.model_dump(mode="json") for svc in services],
+                "id",
+                "name",
+                "image"
+            )
     finally:
         await client.close()
 

meshagent_cli-0.0.31/meshagent/cli/tty.py

@@ -0,0 +1,122 @@
+import pathlib
+import sys
+import tty
+import termios
+from typing import Annotated, Optional
+
+import asyncio
+import typer
+from rich import print
+import aiohttp
+
+from meshagent.api import RoomClient, ParticipantToken
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    print_json_table,
+    set_active_project,
+    resolve_project_id,
+    resolve_api_key,
+)
+
+import os
+
+app = async_typer.AsyncTyper()
+
+@app.async_command("connect")
+async def tty_command(
+    *,
+    project_id: str = None,
+    room: Annotated[str, typer.Option()],
+    api_key_id: Annotated[Optional[str], typer.Option()] = None,
+   
+):
+    """Open an interactive websocket‑based TTY."""
+    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"]
+
+        token = ParticipantToken(
+            name="tty",
+            project_id=project_id,
+            api_key_id=api_key_id
+        )
+
+        token.add_role_grant(role="user")
+
+        token.add_room_grant(room)
+
+        ws_url = f"{os.getenv("MESHAGENT_API_URL").replace("http","ws",1)}/rooms/{room}/tty?token={token.to_jwt(token=key)}"
+
+        print(f"[bold green]Connecting to[/bold green] {room}")
+
+        # Save current terminal settings so we can restore them later.
+        old_tty_settings = termios.tcgetattr(sys.stdin)
+        try:
+            async with aiohttp.ClientSession() as session:
+
+                async with session.ws_connect(ws_url) as websocket:
+
+                    print(f"[bold green]Connected to[/bold green] {room}")
+
+                    tty.setraw(sys.stdin)
+
+                    async def recv_from_websocket():
+                        async for message in websocket:
+
+                            if message.type == aiohttp.WSMsgType.CLOSE:
+                                await websocket.close()
+                            
+                            elif message.type == aiohttp.WSMsgType.ERROR:
+                                await websocket.close()
+                            
+                            data : bytes = message.data
+                            sys.stdout.write(data.decode("utf-8"))
+                            sys.stdout.flush()
+
+                    async def send_to_websocket():
+                        loop = asyncio.get_running_loop()
+
+                        reader = asyncio.StreamReader()
+                        protocol = asyncio.StreamReaderProtocol(reader)
+                        await loop.connect_read_pipe(lambda: protocol, sys.stdin)
+                        
+                        while True:
+                            # Read one character at a time from stdin without blocking the event loop.
+
+
+                            data = await reader.read(1)
+                            if not data:
+                                break
+
+                            if websocket.closed:
+                                break
+                            
+                            if data == b'\x03':
+                                print("<CTRL-C>\n")
+                                break
+
+                            if data:
+                                await websocket.send_bytes(data)
+                            else:
+                                await websocket.close(code=1000)
+                                break
+
+                    done, pending = await asyncio.wait([
+                        asyncio.create_task(recv_from_websocket()),
+                        asyncio.create_task(send_to_websocket())
+                    ], return_when=asyncio.FIRST_COMPLETED)
+
+                    for task in pending:
+                        task.cancel()                    
+
+        finally:
+            # Restore original terminal settings even if the coroutine is cancelled.
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old_tty_settings)
+
+    finally:
+
+        await client.close()

meshagent_cli-0.0.31/meshagent/cli/version.py

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

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent/cli/voicebot.py

@@ -42,7 +42,8 @@ async def make_call(
     rule: Annotated[List[str], typer.Option("--rule", "-r", help="a system rule")] = [],
     toolkit: Annotated[List[str], typer.Option("--toolkit", "-t", help="the name or url of a required toolkit")] = [],
     schema: Annotated[List[str], typer.Option("--schema", "-s", help="the name or url of a required schema")] = [],
-    greeting: Annotated[Optional[str], typer.Option()] = None,
+    auto_greet_message: Annotated[Optional[str], typer.Option()] = None,
+    auto_greet_prompt: Annotated[Optional[str], typer.Option()] = None,
 ):
     account_client = await get_client()
     try:
@@ -75,7 +76,8 @@ async def make_call(
                 requirements.append(RequiredSchema(name=t))
 
             bot = VoiceBot(
-                greeting=greeting,
+                auto_greet_message=auto_greet_message,
+                auto_greet_prompt=auto_greet_prompt,
                 name=agent_name,
                 requires=requirements,
                 rules=rule if len(rule) > 0 else None

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.0.29
+Version: 0.0.31
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -10,11 +10,12 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: typer~=0.15.3
 Requires-Dist: pydantic-yaml~=1.4.0
-Requires-Dist: meshagent-api~=0.0.29
-Requires-Dist: meshagent-agents~=0.0.29
-Requires-Dist: meshagent-tools~=0.0.29
-Requires-Dist: meshagent-mcp~=0.0.29
+Requires-Dist: meshagent-api~=0.0.31
+Requires-Dist: meshagent-agents~=0.0.31
+Requires-Dist: meshagent-tools~=0.0.31
+Requires-Dist: meshagent-mcp~=0.0.31
 Requires-Dist: supabase~=2.15.1
+Requires-Dist: fastmcp~=2.8.1
 
 ### Meshagent CLI
 

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/meshagent_cli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ meshagent/cli/projects.py
 meshagent/cli/services.py
 meshagent/cli/sessions.py
 meshagent/cli/storage.py
+meshagent/cli/tty.py
 meshagent/cli/version.py
 meshagent/cli/voicebot.py
 meshagent/cli/webhook.py

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

@@ -0,0 +1,8 @@
+typer~=0.15.3
+pydantic-yaml~=1.4.0
+meshagent-api~=0.0.31
+meshagent-agents~=0.0.31
+meshagent-tools~=0.0.31
+meshagent-mcp~=0.0.31
+supabase~=2.15.1
+fastmcp~=2.8.1

{meshagent_cli-0.0.29 → meshagent_cli-0.0.31}/pyproject.toml

@@ -11,11 +11,12 @@ keywords = []
 dependencies = [
   "typer~=0.15.3",
   "pydantic-yaml~=1.4.0",
-  "meshagent-api~=0.0.29",
-  "meshagent-agents~=0.0.29",
-  "meshagent-tools~=0.0.29",
-  "meshagent-mcp~=0.0.29",
+  "meshagent-api~=0.0.31",
+  "meshagent-agents~=0.0.31",
+  "meshagent-tools~=0.0.31",
+  "meshagent-mcp~=0.0.31",
   "supabase~=2.15.1",
+  "fastmcp~=2.8.1"
 ]
 dynamic = ["version", "readme"]
 

meshagent_cli-0.0.29/meshagent/cli/projects.py

@@ -1,36 +0,0 @@
-import typer
-from rich import print
-from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, print_json_table, set_active_project, get_active_project
-
-app = async_typer.AsyncTyper()
-
-
-@app.async_command("list")
-async def list():
-    client = await get_client()
-    projects = await client.list_projects()
-    active_project = await get_active_project()
-    for project in projects["projects"]:
-        if project["id"] == active_project:
-            project["name"] = "*" + project["name"]
-
-    print_json_table(projects["projects"], "id", "name")
-    await client.close()
-
-@app.async_command("activate")
-async def activate(project_id: str):
-    client = await get_client()
-    try:
-        projects = await client.list_projects()
-        projects = projects["projects"]
-        for project in projects:
-            if project["id"] == project_id:
-                await set_active_project(project_id=project_id)
-                return
-
-        print(f"[red]Invalid project id: {project_id}[/red]")
-        raise typer.Exit(code=1)
-    finally:
-        await client.close()
-

meshagent_cli-0.0.29/meshagent/cli/version.py

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

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

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