meshagent-cli 0.7.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

meshagent/cli/cli.py

@@ -3,35 +3,35 @@ import asyncio
 
 from meshagent.cli import async_typer
 
-from meshagent.cli import queue
+from meshagent.cli import multi
+
 from meshagent.cli import auth
 from meshagent.cli import api_keys
 from meshagent.cli import projects
 from meshagent.cli import sessions
 from meshagent.cli import participant_token
-from meshagent.cli import agent
-from meshagent.cli import messaging
-from meshagent.cli import storage
-from meshagent.cli import developer
 from meshagent.cli import webhook
 from meshagent.cli import services
-from meshagent.cli import cli_secrets
+from meshagent.cli import mailboxes
+
 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 mailbot
-from meshagent.cli import containers
+from meshagent.cli import worker
+from meshagent.cli import task_runner
 from meshagent.cli import oauth2
 from meshagent.cli import helpers
 from meshagent.cli import meeting_transcriber
+from meshagent.cli import rooms
 from meshagent.cli import room
+from meshagent.cli import port
 from meshagent.cli.exec import register as register_exec
 from meshagent.cli.version import __version__
 from meshagent.cli.helper import get_active_api_key
 from meshagent.otel import otel_config
 
-
 from art import tprint
 
 import logging
@@ -47,30 +47,31 @@ otel_config(service_name="meshagent-cli")
 logging.getLogger("openai").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 
-app = async_typer.AsyncTyper(no_args_is_help=True)
+app = async_typer.AsyncTyper(no_args_is_help=True, name="meshagent")
 app.add_typer(call.app, name="call")
 app.add_typer(auth.app, name="auth")
 app.add_typer(projects.app, name="project")
 app.add_typer(api_keys.app, name="api-key")
 app.add_typer(sessions.app, name="session")
 app.add_typer(participant_token.app, name="participant-token")
-app.add_typer(agent.app, name="agents")
-app.add_typer(messaging.app, name="messaging")
-app.add_typer(storage.app, name="storage")
-app.add_typer(developer.app, name="developer")
 app.add_typer(webhook.app, name="webhook")
 app.add_typer(services.app, name="service")
-app.add_typer(cli_secrets.app, name="secret")
-app.add_typer(queue.app, name="queue")
 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(mailbot.app, name="mailbot")
-app.add_typer(containers.app, name="container")
 app.add_typer(oauth2.app, name="oauth2")
 app.add_typer(helpers.app, name="helpers")
-app.add_typer(room.app, name="room")
+app.add_typer(rooms.app, name="rooms")
+app.add_typer(mailboxes.app, name="mailbox")
 app.add_typer(meeting_transcriber.app, name="meeting-transcriber")
+app.add_typer(port.app, name="port")
+
+app.add_typer(multi.app, name="multi")
+app.add_typer(voicebot.app, name="voicebot")
+app.add_typer(chatbot.app, name="chatbot")
+app.add_typer(mailbot.app, name="mailbot")
+app.add_typer(task_runner.app, name="task-runner")
+app.add_typer(worker.app, name="worker")
+
+app.add_typer(room.app, name="room")
 
 register_exec(app)
 

meshagent/cli/cli_mcp.py

@@ -35,23 +35,30 @@ def _kv_to_dict(pairs: List[str]) -> dict[str, str]:
     return out
 
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Bridge MCP servers into MeshAgent rooms")
 
 
-@app.async_command("sse")
+@app.async_command(
+    "sse", help="Connect an MCP server over SSE and register it as a toolkit"
+)
 async def sse(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "tool",
-    url: Annotated[str, typer.Option()],
-    toolkit_name: Annotated[Optional[str], typer.Option()] = None,
+    url: Annotated[str, typer.Option(..., help="SSE URL for the MCP server")],
+    toolkit_name: Annotated[
+        Optional[str],
+        typer.Option(help="Toolkit name to register in the room (default: mcp)"),
+    ] = None,
     key: Annotated[
         str,
         typer.Option("--key", help="an api key to sign the token with"),
     ] = None,
 ):
+    """Connect an MCP server over SSE and expose it as a room toolkit."""
+
     from mcp.client.session import ClientSession
     from mcp.client.sse import sse_client
 
@@ -116,21 +123,33 @@ async def sse(
         await account_client.close()
 
 
-@app.async_command("stdio")
+@app.async_command(
+    "stdio", help="Run an MCP server over stdio and register it as a toolkit"
+)
 async def stdio(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "tool",
-    command: Annotated[str, typer.Option()],
-    toolkit_name: Annotated[Optional[str], typer.Option()] = None,
+    command: Annotated[
+        str,
+        typer.Option(
+            ..., help="Command to start an MCP server over stdio (quoted string)"
+        ),
+    ],
+    toolkit_name: Annotated[
+        Optional[str],
+        typer.Option(help="Toolkit name to register in the room (default: mcp)"),
+    ] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
     key: Annotated[
         str,
         typer.Option("--key", help="an api key to sign the token with"),
     ] = None,
 ):
+    """Run an MCP server over stdio and expose it as a room toolkit."""
+
     from mcp.client.session import ClientSession
     from mcp.client.stdio import stdio_client, StdioServerParameters
 
@@ -205,16 +224,30 @@ async def stdio(
         await account_client.close()
 
 
-@app.async_command("http-proxy")
+@app.async_command("http-proxy", help="Expose a stdio MCP server over streamable HTTP")
 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,
+    command: Annotated[
+        str,
+        typer.Option(..., help="Command to start the MCP server (stdio transport)"),
+    ],
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the proxy server on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the proxy server on")
+    ] = None,
+    path: Annotated[
+        Optional[str],
+        typer.Option(help="HTTP path to mount the proxy server at"),
+    ] = None,
+    name: Annotated[
+        Optional[str], typer.Option(help="Display name for the proxy server")
+    ] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
 ):
+    """Expose a stdio-based MCP server over streamable HTTP."""
+
     from fastmcp import FastMCP, Client
     from fastmcp.client.transports import StdioTransport
 
@@ -238,16 +271,29 @@ async def stdio_host(
     await proxy.run_async(transport="streamable-http", host=host, port=port, path=path)
 
 
-@app.async_command("sse-proxy")
+@app.async_command("sse-proxy", help="Expose a stdio MCP server over SSE")
 async def sse_proxy(
     *,
-    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,
+    command: Annotated[
+        str,
+        typer.Option(..., help="Command to start the MCP server (stdio transport)"),
+    ],
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the proxy server on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the proxy server on")
+    ] = None,
+    path: Annotated[
+        Optional[str], typer.Option(help="SSE path to mount the proxy at")
+    ] = None,
+    name: Annotated[
+        Optional[str], typer.Option(help="Display name for the proxy server")
+    ] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
 ):
+    """Expose a stdio-based MCP server over SSE."""
+
     from fastmcp import FastMCP, Client
     from fastmcp.client.transports import StdioTransport
 
@@ -271,17 +317,35 @@ async def sse_proxy(
     await proxy.run_async(transport="sse", host=host, port=port, path=path)
 
 
-@app.async_command("stdio-service")
+@app.async_command("stdio-service", help="Run a stdio MCP server as an HTTP service")
 async def stdio_service(
     *,
-    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,
+    command: Annotated[
+        str,
+        typer.Option(
+            ..., help="Command to start an MCP server over stdio (quoted string)"
+        ),
+    ],
+    host: Annotated[
+        Optional[str], typer.Option(help="Host to bind the service on")
+    ] = None,
+    port: Annotated[
+        Optional[int], typer.Option(help="Port to bind the service on")
+    ] = None,
+    webhook_secret: Annotated[
+        Optional[str],
+        typer.Option(help="Optional webhook secret for authenticating requests"),
+    ] = None,
+    path: Annotated[
+        Optional[str], typer.Option(help="HTTP path to mount the service at")
+    ] = None,
+    toolkit_name: Annotated[
+        Optional[str], typer.Option(help="Toolkit name to expose (default: mcp)")
+    ] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
 ):
+    """Run a stdio-based MCP server as an HTTP service."""
+
     from mcp.client.session import ClientSession
     from mcp.client.stdio import stdio_client, StdioServerParameters
 

meshagent/cli/cli_secrets.py

@@ -53,7 +53,7 @@ keys_app = async_typer.AsyncTyper(
 @keys_app.async_command("create")
 async def create_keys_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     name: Annotated[str, typer.Option(help="Secret name")],
     data: Annotated[
         str,
@@ -86,7 +86,7 @@ async def create_keys_secret(
 @keys_app.async_command("update")
 async def update_keys_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
     name: Annotated[str, typer.Option(help="Secret name")],
     data: Annotated[
@@ -128,7 +128,7 @@ docker_app = async_typer.AsyncTyper(
 @docker_app.async_command("create")
 async def create_docker_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[
         str, typer.Option(help="Docker registry server, e.g. index.docker.io")
@@ -166,7 +166,7 @@ async def create_docker_secret(
 @docker_app.async_command("update")
 async def update_docker_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[str, typer.Option(help="Docker registry server")],
@@ -211,7 +211,7 @@ acr_app = async_typer.AsyncTyper(
 @acr_app.async_command("create")
 async def create_acr_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[str, typer.Option(help="ACR server, e.g. myregistry.azurecr.io")],
     username: Annotated[str, typer.Option(help="Service principal ID")],
@@ -241,7 +241,7 @@ async def create_acr_secret(
 @acr_app.async_command("update")
 async def update_acr_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[str, typer.Option(help="ACR server, e.g. myregistry.azurecr.io")],
@@ -281,7 +281,7 @@ gar_app = async_typer.AsyncTyper(
 @gar_app.async_command("create")
 async def create_gar_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[str, typer.Option(help="GAR host, e.g. us-west1-docker.pkg.dev")],
     json_key: Annotated[
@@ -314,7 +314,7 @@ async def create_gar_secret(
 @gar_app.async_command("update")
 async def update_gar_secret(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     secret_id: Annotated[str, typer.Option(help="Existing secret ID")],
     name: Annotated[str, typer.Option(help="Secret name")],
     server: Annotated[str, typer.Option(help="GAR host, e.g. us-west1-docker.pkg.dev")],
@@ -348,7 +348,7 @@ async def update_gar_secret(
 
 
 @secrets_app.async_command("list")
-async def secret_list(*, project_id: ProjectIdOption = None):
+async def secret_list(*, project_id: ProjectIdOption):
     """List all secrets in the project (typed as Docker/ACR/GAR or Keys secrets)."""
     client = await get_client()
     try:
@@ -383,7 +383,7 @@ async def secret_list(*, project_id: ProjectIdOption = None):
 @secrets_app.async_command("delete")
 async def secret_delete(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     secret_id: Annotated[str, typer.Argument(help="ID of the secret to delete")],
 ):
     """Delete a secret."""

meshagent/cli/common_options.py

@@ -1,28 +1,43 @@
 import typer
 from typing import Annotated, Optional
+import os
+from meshagent.cli.helper import _load_settings
 
 OutputFormatOption = Annotated[
     str,
     typer.Option("--output", "-o", help="output format [json|table]"),
 ]
 
+if os.getenv("MESHAGENT_CLI_BUILD"):
+    default_project_id = None
+else:
+    settings = _load_settings()
+    if settings is None:
+        default_project_id = None
+    else:
+        default_project_id = settings.active_project
+
+
+def get_default_project_id():
+    return os.getenv("MESHAGENT_PROJECT_ID") or default_project_id
+
+
 ProjectIdOption = Annotated[
     Optional[str],
     typer.Option(
         "--project-id",
         help="A MeshAgent project id. If empty, the activated project will be used.",
+        default_factory=get_default_project_id(),
     ),
 ]
 
 RoomOption = Annotated[
-    str,
+    Optional[str],
     typer.Option(
-        "--room",
-        help="Room name",
+        "--room", help="Room name", default_factory=os.getenv("MESHAGENT_ROOM")
     ),
 ]
 
-
 RoomCreateOption = Annotated[
     bool,
     typer.Option(

meshagent/cli/containers.py

@@ -33,6 +33,8 @@ from meshagent.api.room_server_client import (
     DockerSecret,
 )
 
+import sys
+
 app = async_typer.AsyncTyper(help="Manage containers and images inside a room")
 
 # -------------------------
@@ -353,7 +355,6 @@ async def _with_client(
 
         connection = await account_client.connect_room(project_id=project_id, room=room)
 
-        print("[bold green]Connecting to room...[/bold green]", flush=True)
         proto = WebSocketClientProtocol(
             url=websocket_room_url(room_name=room, base_url=meshagent_base_url()),
             token=connection.jwt,
@@ -374,7 +375,7 @@ async def _with_client(
 @app.async_command("ps")
 async def list_containers(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     output: Annotated[Optional[str], typer.Option(help="json | table")] = "json",
 ):
@@ -407,7 +408,7 @@ async def list_containers(
 @app.async_command("stop")
 async def stop_container(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     id: Annotated[str, typer.Option(..., help="Container ID")],
 ):
@@ -426,10 +427,12 @@ async def stop_container(
 @app.async_command("logs")
 async def container_logs(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     id: Annotated[str, typer.Option(..., help="Container ID")],
-    follow: Annotated[bool, typer.Option("--follow/--no-follow")] = False,
+    follow: Annotated[
+        bool, typer.Option("--follow/--no-follow", help="Stream logs")
+    ] = False,
 ):
     account_client, client = await _with_client(
         project_id=project_id,
@@ -443,18 +446,151 @@ async def container_logs(
         await account_client.close()
 
 
+@app.async_command("exec")
+async def exec_container(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+    container_id: Annotated[str, typer.Option(..., help="container id")],
+    command: Annotated[
+        Optional[str],
+        typer.Option(..., help="Command to execute in the container (quoted string)"),
+    ] = None,
+    tty: Annotated[bool, typer.Option(..., help="Allocate a TTY")] = False,
+):
+    account_client, client = await _with_client(
+        project_id=project_id,
+        room=room,
+    )
+    result = 1
+
+    try:
+        import termios
+
+        from contextlib import contextmanager
+
+        container = await client.containers.exec(
+            container_id=container_id,
+            command=command,
+            tty=tty,
+        )
+
+        async def write_all(fd, data: bytes) -> None:
+            loop = asyncio.get_running_loop()
+            mv = memoryview(data)
+
+            while mv:
+                try:
+                    n = os.write(fd, mv)
+                    mv = mv[n:]
+                except BlockingIOError:
+                    fut = loop.create_future()
+                    loop.add_writer(fd, fut.set_result, None)
+                    try:
+                        await fut
+                    finally:
+                        loop.remove_writer(fd)
+
+        async def read_stderr():
+            async for output in container.stderr():
+                await write_all(sys.stderr.fileno(), output)
+
+        async def read_stdout():
+            async for output in container.stdout():
+                await write_all(sys.stdout.fileno(), output)
+
+        @contextmanager
+        def raw_mode(fd: int):
+            import tty
+
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)  # immediate bytes
+                yield
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+        async def read_piped_stdin(bufsize: int = 1024):
+            while True:
+                chunk = await asyncio.to_thread(sys.stdin.buffer.read, bufsize)
+
+                if not chunk or len(chunk) == 0:
+                    await container.close_stdin()
+                    break
+
+                await container.write(chunk)
+
+        async def read_stdin(bufsize: int = 1024):
+            # If stdin is piped, just read normally (blocking is fine; no TTY semantics)
+            if not sys.stdin.isatty():
+                while True:
+                    chunk = sys.stdin.buffer.read(bufsize)
+                    if not chunk:
+                        return
+                    await container.write(chunk)
+                return
+
+            fd = sys.stdin.fileno()
+
+            # Make reads non-blocking so we never hang shutdown
+            prev_blocking = os.get_blocking(fd)
+            os.set_blocking(fd, False)
+
+            try:
+                with raw_mode(fd):
+                    while True:
+                        try:
+                            chunk = os.read(fd, bufsize)
+                        except BlockingIOError:
+                            # nothing typed yet
+                            await asyncio.sleep(0.01)
+                            continue
+
+                        if chunk == b"":
+                            return
+
+                        # optional: allow Ctrl-C to exit
+                        if chunk == b"\x03":
+                            return
+
+                        await container.write(chunk)
+            finally:
+                os.set_blocking(fd, prev_blocking)
+
+        if not tty and not sys.stdin.isatty():
+            await asyncio.gather(read_stdout(), read_stderr(), read_piped_stdin())
+        else:
+            if not sys.stdin.isatty():
+                print("[red]TTY requested but not a TTY[/red]")
+                raise typer.Exit(-1)
+
+            reader = asyncio.create_task(read_stdin())
+            await asyncio.gather(read_stdout(), read_stderr())
+            reader.cancel()
+
+        result = await container.result
+    finally:
+        await client.__aexit__(None, None, None)
+        await account_client.close()
+
+    sys.exit(result)
+
+
 # -------------------------
-# Run (detached) and run-attached
+# Run (detached)
 # -------------------------
 
 
 @app.async_command("run")
 async def run_container(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     image: Annotated[str, typer.Option(..., help="Image to run")],
-    command: Annotated[Optional[str], typer.Option(...)] = None,
+    command: Annotated[
+        Optional[str],
+        typer.Option(..., help="Command to execute in the container (quoted string)"),
+    ] = None,
     env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
     port: Annotated[
         List[str], typer.Option("--port", "-p", help="CONTAINER:HOST")
@@ -470,11 +606,23 @@ async def run_container(
             help="Docker creds (username,password) or (registry,username,password)",
         ),
     ] = [],
-    mount_path: Annotated[Optional[str], typer.Option()] = None,
-    mount_subpath: Annotated[Optional[str], typer.Option()] = None,
-    participant_name: Annotated[Optional[str], typer.Option()] = None,
-    role: Annotated[str, typer.Option(...)] = "user",
-    container_name: Annotated[str, typer.Option(...)] = None,
+    mount_path: Annotated[
+        Optional[str],
+        typer.Option(help="Room storage path to mount into the container"),
+    ] = None,
+    mount_subpath: Annotated[
+        Optional[str],
+        typer.Option(help="Subpath within `--mount-path` to mount"),
+    ] = None,
+    participant_name: Annotated[
+        Optional[str], typer.Option(help="Participant name to associate with the run")
+    ] = None,
+    role: Annotated[
+        str, typer.Option(..., help="Role to run the container as")
+    ] = "user",
+    container_name: Annotated[
+        str, typer.Option(..., help="Optional container name")
+    ] = None,
 ):
     account_client, client = await _with_client(
         project_id=project_id,
@@ -517,7 +665,7 @@ app.add_typer(images_app, name="images")
 @images_app.async_command("list")
 async def images_list(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
 ):
     account_client, client = await _with_client(
@@ -535,7 +683,7 @@ async def images_list(
 @images_app.async_command("delete")
 async def images_delete(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     image: Annotated[str, typer.Option(..., help="Image ref/tag to delete")],
 ):
@@ -554,7 +702,7 @@ async def images_delete(
 @images_app.async_command("pull")
 async def images_pull(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     tag: Annotated[str, typer.Option(..., help="Image tag/ref to pull")],
     cred: Annotated[