meshagent-cli 0.0.39__py3-none-any.whl → 0.2.0__py3-none-any.whl

meshagent/cli/call.py

@@ -72,10 +72,16 @@ async def make_call(
     project_id: str = None,
     room: Annotated[str, typer.Option()],
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "agent",
     local: Optional[bool] = None,
-    agent_name: Annotated[str, typer.Option(..., help="Name of the agent to call")],
+    agent_name: Annotated[
+        Optional[str], typer.Option(..., help="deprecated and unused", hidden=True)
+    ] = None,
+    name: Annotated[str, typer.Option(..., help="deprecated", hidden=True)] = None,
+    participant_name: Annotated[
+        Optional[str],
+        typer.Option(..., help="the participant name to be used by the callee"),
+    ] = None,
     url: Annotated[str, typer.Option(..., help="URL the agent should call")],
     arguments: Annotated[
         str, typer.Option(..., help="JSON string with arguments for the call")
@@ -83,7 +89,22 @@ async def make_call(
 ):
     """
     Instruct an agent to 'call' a given URL with specific arguments.
+
     """
+
+    if name is not None:
+        print("[yellow]name is deprecated and should no longer be passed[/yellow]")
+
+    if agent_name is not None:
+        print(
+            "[yellow]agent-name is deprecated and should no longer be passed, use participant-name instead[/yellow]"
+        )
+        participant_name = agent_name
+
+    if participant_name is None:
+        print("[red]--participant-name is required[/red]")
+        raise typer.Exit(1)
+
     account_client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
@@ -96,7 +117,7 @@ async def make_call(
         )["token"]
 
         token = ParticipantToken(
-            name=name, project_id=project_id, api_key_id=api_key_id
+            name=participant_name, project_id=project_id, api_key_id=api_key_id
         )
         token.add_role_grant(role=role)
         token.add_room_grant(room)
@@ -130,7 +151,7 @@ async def make_call(
             ) as client:
                 print("[bold green]Making agent call...[/bold green]")
                 await client.agents.make_call(
-                    name=agent_name, url=url, arguments=json.loads(arguments)
+                    name=participant_name, url=url, arguments=json.loads(arguments)
                 )
                 print("[bold cyan]Call request sent successfully.[/bold cyan]")
 

meshagent/cli/cli.py

@@ -2,6 +2,8 @@ import typer
 import asyncio
 from typing import Optional
 
+from meshagent.cli import async_typer
+
 from meshagent.cli import auth
 from meshagent.cli import api_keys
 from meshagent.cli import projects
@@ -18,7 +20,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
+from meshagent.cli.exec import register as register_exec
 
 from meshagent.cli import otel
 
@@ -38,7 +40,7 @@ otel.init(level=logging.INFO)
 logging.getLogger("openai").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 
-app = typer.Typer()
+app = async_typer.AsyncTyper()
 app.add_typer(call.app, name="call")
 app.add_typer(auth.app, name="auth")
 app.add_typer(projects.app, name="project")
@@ -55,7 +57,8 @@ 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")
+
+register_exec(app)
 
 
 def _run_async(coro):

meshagent/cli/exec.py

@@ -0,0 +1,286 @@
+import sys
+import tty as _tty
+import termios
+from meshagent.api.websocket_protocol import WebSocketClientProtocol
+from meshagent.api import RoomClient
+from meshagent.api.helpers import websocket_room_url
+from typing import Annotated, Optional
+import asyncio
+import typer
+from rich import print
+import aiohttp
+import struct
+import signal
+import shutil
+import json
+from urllib.parse import quote
+
+from meshagent.api import ParticipantToken
+
+import logging
+
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_api_key,
+)
+
+
+def register(app: typer.Typer):
+    @app.async_command("exec")
+    async def exec_command(
+        *,
+        project_id: str = None,
+        room: Annotated[str, typer.Option()],
+        name: Annotated[Optional[str], typer.Option()] = None,
+        image: Annotated[Optional[str], typer.Option()] = None,
+        api_key_id: Annotated[Optional[str], typer.Option()] = None,
+        command: Annotated[list[str], typer.Argument(...)] = None,
+        tty: bool = False,
+    ):
+        """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
+            )
+
+            token = ParticipantToken(
+                name="tty", 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.add_role_grant(role="user")
+            token.add_room_grant(room)
+
+            ws_url = (
+                websocket_room_url(room_name=room)
+                + f"/exec?token={token.to_jwt(token=key)}"
+            )
+
+            if image:
+                ws_url += f"&image={quote(' '.join(image))}"
+
+            if name:
+                ws_url += f"&name={quote(' '.join(name))}"
+
+            if command and len(command) != 0:
+                ws_url += f"&command={quote(' '.join(command))}"
+
+            if tty:
+                if not sys.stdin.isatty():
+                    print("[red]TTY requested but process is not a TTY[/red]")
+                    raise typer.Exit(1)
+
+                ws_url += "&tty=true"
+
+            else:
+                if command is None:
+                    print("[red]TTY required when not executing a command[/red]")
+                    raise typer.Exit(1)
+
+                ws_url += "&tty=false"
+
+            if tty:
+                # Save current terminal settings so we can restore them later.
+                old_tty_settings = termios.tcgetattr(sys.stdin)
+                _tty.setraw(sys.stdin)
+
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(
+                    url=websocket_room_url(room_name=room),
+                    token=token.to_jwt(token=key),
+                )
+            ):
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.ws_connect(ws_url) as websocket:
+                            send_queue = asyncio.Queue[bytes]()
+
+                            loop = asyncio.get_running_loop()
+                            (
+                                stdout_transport,
+                                stdout_protocol,
+                            ) = await loop.connect_write_pipe(
+                                asyncio.streams.FlowControlMixin, sys.stdout
+                            )
+                            stdout_writer = asyncio.StreamWriter(
+                                stdout_transport, stdout_protocol, None, loop
+                            )
+
+                            (
+                                stderr_transport,
+                                stderr_protocol,
+                            ) = await loop.connect_write_pipe(
+                                asyncio.streams.FlowControlMixin, sys.stderr
+                            )
+                            stderr_writer = asyncio.StreamWriter(
+                                stderr_transport, stderr_protocol, None, loop
+                            )
+
+                            async def recv_from_websocket():
+                                while True:
+                                    done, pending = await asyncio.wait(
+                                        [asyncio.create_task(websocket.receive())],
+                                        return_when=asyncio.FIRST_COMPLETED,
+                                    )
+
+                                    first = done.pop()
+
+                                    if first == read_stdin_task:
+                                        break
+
+                                    message = first.result()
+
+                                    if websocket.closed:
+                                        break
+
+                                    if message.type == aiohttp.WSMsgType.CLOSE:
+                                        break
+
+                                    elif message.type == aiohttp.WSMsgType.CLOSING:
+                                        pass
+
+                                    elif message.type == aiohttp.WSMsgType.ERROR:
+                                        break
+
+                                    if not message.data:
+                                        break
+
+                                    data: bytes = message.data
+                                    if len(data) > 0:
+                                        if data[0] == 1:
+                                            stderr_writer.write(data)
+                                            await stderr_writer.drain()
+                                        elif data[0] == 0:
+                                            stdout_writer.write(data)
+                                            await stdout_writer.drain()
+                                        else:
+                                            raise ValueError(
+                                                f"Invalid channel received {data[0]}"
+                                            )
+
+                            last_size = None
+
+                            async def send_resize(rows, cols):
+                                nonlocal last_size
+
+                                size = (cols, rows)
+                                if size == last_size:
+                                    return
+
+                                last_size = size
+
+                                resize_json = json.dumps(
+                                    {"Width": cols, "Height": rows}
+                                ).encode("utf-8")
+                                payload = struct.pack("B", 4) + resize_json
+                                send_queue.put_nowait(payload)
+                                await asyncio.sleep(5)
+
+                            cols, rows = shutil.get_terminal_size(fallback=(24, 80))
+                            if tty:
+                                await send_resize(rows, cols)
+
+                            def on_sigwinch():
+                                cols, rows = shutil.get_terminal_size(fallback=(24, 80))
+                                task = asyncio.create_task(send_resize(rows, cols))
+
+                                def on_done(t: asyncio.Task):
+                                    t.result()
+
+                                task.add_done_callback(on_done)
+
+                            loop.add_signal_handler(signal.SIGWINCH, on_sigwinch)
+
+                            async def read_stdin():
+                                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.
+                                    done, pending = await asyncio.wait(
+                                        [
+                                            asyncio.create_task(reader.read(1)),
+                                            websocket_recv_task,
+                                        ],
+                                        return_when=asyncio.FIRST_COMPLETED,
+                                    )
+
+                                    first = done.pop()
+                                    if first == websocket_recv_task:
+                                        break
+
+                                    data = first.result()
+                                    if not data:
+                                        break
+
+                                    if websocket.closed:
+                                        break
+
+                                    if tty:
+                                        if data == b"\x04":
+                                            break
+
+                                    if data:
+                                        send_queue.put_nowait(b"\0" + data)
+                                    else:
+                                        break
+
+                                send_queue.put_nowait(b"\0")
+
+                            websocket_recv_task = asyncio.create_task(
+                                recv_from_websocket()
+                            )
+                            read_stdin_task = asyncio.create_task(read_stdin())
+
+                            async def send_to_websocket():
+                                while True:
+                                    try:
+                                        data = await send_queue.get()
+                                        if websocket.closed:
+                                            break
+
+                                        if data is not None:
+                                            await websocket.send_bytes(data)
+
+                                        else:
+                                            break
+                                    except asyncio.QueueShutDown:
+                                        break
+
+                            send_to_websocket_task = asyncio.create_task(
+                                send_to_websocket()
+                            )
+                            await asyncio.gather(
+                                websocket_recv_task,
+                                read_stdin_task,
+                            )
+
+                            send_queue.shutdown()
+                            await send_to_websocket_task
+
+                finally:
+                    if not sys.stdin.closed and tty:
+                        # Restore original terminal settings even if the coroutine is cancelled.
+                        termios.tcsetattr(
+                            sys.stdin, termios.TCSADRAIN, old_tty_settings
+                        )
+
+        except Exception as e:
+            print(f"[red]{e}[/red]")
+            logging.error("failed", exc_info=e)
+            raise typer.Exit(1)
+        finally:
+            await client.close()

meshagent/cli/services.py

@@ -10,6 +10,7 @@ from pydantic import PositiveInt
 import pydantic
 from typing import Literal
 from meshagent.cli import async_typer
+from pydantic import BaseModel
 from meshagent.cli.helper import (
     get_client,
     print_json_table,
@@ -24,8 +25,11 @@ from meshagent.api import (
     meshagent_base_url,
 )
 
+from pydantic_yaml import parse_yaml_raw_as
+
 # Pydantic basemodels
-from meshagent.api.accounts_client import Service, Port, Services
+from meshagent.api.accounts_client import Service, Port, Services, Endpoint
+
 
 app = async_typer.AsyncTyper()
 
@@ -88,9 +92,17 @@ def _parse_port_spec(spec: str) -> PortSpec:
 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)")] = None,
+    file: Annotated[
+        Optional[str],
+        typer.Option("--file", "-f", help="File path to a service definition"),
+    ] = None,
+    name: Annotated[Optional[str], typer.Option(help="Friendly service name")] = None,
+    image: Annotated[
+        Optional[str], typer.Option(help="Container image reference")
+    ] = None,
+    role: Annotated[
+        Optional[str], typer.Option(help="Service role (agent|tool)")
+    ] = None,
     pull_secret: Annotated[
         Optional[str],
         typer.Option("--pull-secret", help="Secret ID for registry"),
@@ -106,6 +118,13 @@ async def service_create(
         Optional[str],
         typer.Option("--mount", help="Path inside container to mount room storage"),
     ] = None,
+    room_storage_subpath: Annotated[
+        Optional[str],
+        typer.Option(
+            "--mount-subpath",
+            help="Restrict the container's mount to a subpath within the room storage",
+        ),
+    ] = None,
     port: Annotated[
         List[str],
         typer.Option(
@@ -116,40 +135,50 @@ async def service_create(
                 '  -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()
     try:
         project_id = await resolve_project_id(project_id)
 
-        # ✅ validate / coerce port specs
-        port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+        if file is not None:
+            with open(file, "rb") as f:
+                spec = parse_yaml_raw_as(ServiceSpec, f.read())
+                if spec.id is not None:
+                    print("[red]id cannot be set when creating a service[/red]")
+                    raise typer.Exit(code=1)
 
-        ports_dict = {
-            ps.num: Port(
-                type=ps.type,
-                liveness_path=ps.liveness,
-                participant_name=ps.participant_name,
-                path=ps.path,
-            )
-            for ps in port_specs
-        } or None
+                service_obj = spec.to_service()
 
-        service_obj = Service(
-            id="",
-            created_at=datetime.now(timezone.utc).isoformat(),
-            name=name,
-            role=role,
-            image=image,
-            command=command,
-            pull_secret=pull_secret,
-            room_storage_path=room_storage_path,
-            environment=_kv_to_dict(env),
-            environment_secrets=env_secret or None,
-            runtime_secrets=_kv_to_dict(runtime_secret),
-            ports=ports_dict,
-        )
+        else:
+            # ✅ validate / coerce port specs
+            port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+
+            ports_dict = {
+                ps.num: Port(
+                    type=ps.type,
+                    liveness_path=ps.liveness,
+                    participant_name=ps.participant_name,
+                    path=ps.path,
+                )
+                for ps in port_specs
+            } or None
+
+            service_obj = Service(
+                created_at=datetime.now(timezone.utc).isoformat(),
+                name=name,
+                role=role,
+                image=image,
+                command=command,
+                pull_secret=pull_secret,
+                room_storage_path=room_storage_path,
+                room_storage_subpath=room_storage_subpath,
+                environment=_kv_to_dict(env),
+                environment_secrets=env_secret or None,
+                runtime_secrets=_kv_to_dict(runtime_secret),
+                ports=ports_dict,
+            )
 
         try:
             new_id = (
@@ -157,7 +186,7 @@ async def service_create(
             )["id"]
         except ClientResponseError as exc:
             if exc.status == 409:
-                print(f"[red]Service name already in use: {name}[/red]")
+                print(f"[red]Service name already in use: {service_obj.name}[/red]")
                 raise typer.Exit(code=1)
             raise
         else:
@@ -167,20 +196,221 @@ async def service_create(
         await client.close()
 
 
+@app.async_command("update")
+async def service_update(
+    *,
+    project_id: str = None,
+    id: Optional[str] = None,
+    file: Annotated[
+        Optional[str],
+        typer.Option("--file", "-f", help="File path to a service definition"),
+    ] = None,
+    name: Annotated[Optional[str], typer.Option(help="Friendly service name")] = None,
+    image: Annotated[
+        Optional[str], typer.Option(help="Container image reference")
+    ] = None,
+    role: Annotated[
+        Optional[str], typer.Option(help="Service role (agent|tool)")
+    ] = None,
+    pull_secret: Annotated[
+        Optional[str],
+        typer.Option("--pull-secret", help="Secret ID for registry"),
+    ] = None,
+    command: Annotated[
+        Optional[str],
+        typer.Option("--command", help="Override ENTRYPOINT/CMD"),
+    ] = None,
+    env: Annotated[List[str], typer.Option("--env", "-e", help="KEY=VALUE")] = [],
+    env_secret: Annotated[List[str], typer.Option("--env-secret")] = [],
+    runtime_secret: Annotated[List[str], typer.Option("--runtime-secret")] = [],
+    room_storage_path: Annotated[
+        Optional[str],
+        typer.Option("--mount", help="Path inside container to mount room storage"),
+    ] = None,
+    room_storage_subpath: Annotated[
+        Optional[str],
+        typer.Option(
+            "--mount-subpath",
+            help="Restrict the container's mount to a subpath within the room storage",
+        ),
+    ] = None,
+    port: Annotated[
+        List[str],
+        typer.Option(
+            "--port",
+            "-p",
+            help=(
+                "Repeatable. Example:\n"
+                '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health path=/agent participant_name=myname"'
+            ),
+        ),
+    ] = [],
+    create: Annotated[
+        Optional[bool],
+        typer.Option(
+            help="create the service if it does not exist",
+        ),
+    ] = False,
+):
+    """Create a service attached to the project."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        if file is not None:
+            with open(file, "rb") as f:
+                spec = parse_yaml_raw_as(ServiceSpec, f.read())
+                if spec.id is not None:
+                    id = spec.id
+                service_obj = spec.to_service()
+
+        else:
+            # ✅ validate / coerce port specs
+            port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+
+            ports_dict = {
+                ps.num: Port(
+                    type=ps.type,
+                    liveness_path=ps.liveness,
+                    participant_name=ps.participant_name,
+                    path=ps.path,
+                )
+                for ps in port_specs
+            } or None
+
+            service_obj = Service(
+                created_at=datetime.now(timezone.utc).isoformat(),
+                name=name,
+                role=role,
+                image=image,
+                command=command,
+                pull_secret=pull_secret,
+                room_storage_path=room_storage_path,
+                room_storage_subpath=room_storage_subpath,
+                environment=_kv_to_dict(env),
+                environment_secrets=env_secret or None,
+                runtime_secrets=_kv_to_dict(runtime_secret),
+                ports=ports_dict,
+            )
+
+        try:
+            if id is None:
+                services = await client.list_services(project_id=project_id)
+                for s in services:
+                    if s.name == service_obj.name:
+                        id = s.id
+
+            if id is None and not create:
+                print("[red]pass a service id or specify --create[/red]")
+                raise typer.Exit(code=1)
+
+            if id is None:
+                id = (
+                    await client.create_service(
+                        project_id=project_id, service=service_obj
+                    )
+                )["id"]
+
+            else:
+                await client.update_service(
+                    project_id=project_id, service_id=id, service=service_obj
+                )
+
+        except ClientResponseError as exc:
+            if exc.status == 409:
+                print(f"[red]Service name already in use: {service_obj.name}[/red]")
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Updated service:[/] {id}")
+
+    finally:
+        await client.close()
+
+
+class ServicePortEndpointSpec(pydantic.BaseModel):
+    path: str
+    identity: str
+    type: Optional[Literal["mcp.sse", "meshagent.callable", "http", "tcp"]] = None
+
+
+class ServicePortSpec(pydantic.BaseModel):
+    num: PositiveInt
+    type: Literal["mcp.sse", "meshagent.callable", "http", "tcp"]
+    endpoints: list[ServicePortEndpointSpec] = []
+    liveness: Optional[str] = None
+
+
+class ServiceSpec(BaseModel):
+    version: Literal["v1"]
+    kind: Literal["Service"]
+    id: Optional[str] = None
+    name: str
+    command: Optional[str] = None
+    image: str
+    ports: Optional[list[ServicePortSpec]] = []
+    role: Optional[Literal["user", "tool", "agent"]] = None
+    environment: Optional[dict[str, str]] = {}
+    secrets: list[str] = []
+    pull_secret: Optional[str] = None
+    room_storage_path: Optional[str] = None
+    room_storage_subpath: Optional[str] = None
+
+    def to_service(self):
+        ports = {}
+        for p in self.ports:
+            port = Port(liveness_path=p.liveness, type=p.type, endpoints=[])
+            for endpoint in p.endpoints:
+                type = port.type
+                if endpoint.type is not None:
+                    type = endpoint.type
+
+                port.endpoints.append(
+                    Endpoint(
+                        type=type,
+                        participant_name=endpoint.identity,
+                        path=endpoint.path,
+                    )
+                )
+            ports[p.num] = port
+        return Service(
+            id="",
+            created_at=datetime.now(timezone.utc).isoformat(),
+            name=self.name,
+            command=self.command,
+            image=self.image,
+            ports=ports,
+            role=self.role,
+            environment=self.environment,
+            environment_secrets=self.secrets,
+            pull_secret=self.pull_secret,
+            room_storage_path=self.room_storage_path,
+            room_storage_subpath=self.room_storage_subpath,
+        )
+
+
 @app.async_command("test")
 async def service_test(
     *,
     project_id: str = None,
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
+    file: Annotated[
+        Optional[str],
+        typer.Option("--file", "-f", help="File path to a service definition"),
+    ],
     room: Annotated[
-        str,
+        Optional[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)")] = None,
-    image: Annotated[str, typer.Option(help="Container image reference")],
+    ] = None,
+    name: Annotated[Optional[str], typer.Option(help="Friendly service name")] = None,
+    role: Annotated[
+        Optional[str], typer.Option(help="Service role (agent|tool)")
+    ] = None,
+    image: Annotated[
+        Optional[str], typer.Option(help="Container image reference")
+    ] = None,
     pull_secret: Annotated[
         Optional[str],
         typer.Option("--pull-secret", help="Secret ID for registry"),
@@ -206,7 +436,7 @@ async def service_test(
                 '  -p "num=8080 type=[mcp.sse | meshagent.callable | http | tcp] liveness=/health path=/agent participant_name=myname"'
             ),
         ),
-    ] = ...,
+    ] = [],
     timeout: Annotated[
         Optional[int],
         typer.Option(
@@ -221,33 +451,37 @@ async def service_test(
 
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
-        # ✅ validate / coerce port specs
-        port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+        if file is not None:
+            with open(file, "rb") as f:
+                service_obj = parse_yaml_raw_as(ServiceSpec, f.read()).to_service()
 
-        ports_dict = {
-            ps.num: Port(
-                type=ps.type,
-                liveness_path=ps.liveness,
-                participant_name=ps.participant_name,
-                path=ps.path,
+        else:
+            # ✅ validate / coerce port specs
+            port_specs: List[PortSpec] = [_parse_port_spec(s) for s in port]
+
+            ports_dict = {
+                str(ps.num): Port(
+                    type=ps.type,
+                    liveness_path=ps.liveness,
+                    participant_name=ps.participant_name,
+                    path=ps.path,
+                )
+                for ps in port_specs
+            } or None
+
+            service_obj = Service(
+                created_at=datetime.now(timezone.utc).isoformat(),
+                role=role,
+                name=name,
+                image=image,
+                command=command,
+                pull_secret=pull_secret,
+                room_storage_path=room_storage_path,
+                environment=_kv_to_dict(env),
+                environment_secrets=env_secret or None,
+                runtime_secrets=_kv_to_dict(runtime_secret),
+                ports=ports_dict,
             )
-            for ps in port_specs
-        } or None
-
-        service_obj = Service(
-            id="",
-            created_at=datetime.now(timezone.utc).isoformat(),
-            role=role,
-            name=name,
-            image=image,
-            command=command,
-            pull_secret=pull_secret,
-            room_storage_path=room_storage_path,
-            environment=_kv_to_dict(env),
-            environment_secrets=env_secret or None,
-            runtime_secrets=_kv_to_dict(runtime_secret),
-            ports=ports_dict,
-        )
 
         try:
             token = ParticipantToken(

meshagent/cli/storage.py

@@ -112,7 +112,7 @@ async def storage_cp_command(
     ] = None,
     name: Annotated[
         str, typer.Option(..., help="Participant name (if copying to/from remote)")
-    ],
+    ] = "cli",
     role: str = "user",
     source_path: str,
     dest_path: str,

meshagent/cli/version.py

@@ -1 +1 @@
-__version__ = "0.0.39"
+__version__ = "0.2.0"

{meshagent_cli-0.0.39.dist-info → meshagent_cli-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.0.39
+Version: 0.2.0
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -10,15 +10,18 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: typer~=0.15
 Requires-Dist: pydantic-yaml~=1.4
-Requires-Dist: meshagent-api~=0.0.39
-Requires-Dist: meshagent-agents~=0.0.39
-Requires-Dist: meshagent-tools~=0.0.39
-Requires-Dist: meshagent-mcp~=0.0.39
+Requires-Dist: meshagent-api~=0.2.0
+Requires-Dist: meshagent-agents~=0.2.0
+Requires-Dist: meshagent-computers~=0.2.0
+Requires-Dist: meshagent-openai~=0.2.0
+Requires-Dist: meshagent-tools~=0.2.0
+Requires-Dist: meshagent-mcp~=0.2.0
 Requires-Dist: supabase~=2.15
 Requires-Dist: fastmcp~=2.8
 Requires-Dist: opentelemetry-distro~=0.54b1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.33
 Requires-Dist: art~=6.5
+Requires-Dist: pydantic-yaml~=1.5
 
 ## MeshAgent CLI
 

{meshagent_cli-0.0.39.dist-info → meshagent_cli-0.2.0.dist-info}/RECORD

@@ -4,26 +4,26 @@ meshagent/cli/api_keys.py,sha256=4mBqyh_WAogaMIYhRBQOCjfsSSp1RY9BqiI_6DaGLmk,496
 meshagent/cli/async_typer.py,sha256=GCeSefBDbpd-V4V8LrvHGUTBMth3HspVMfFa-HUZ0cg,898
 meshagent/cli/auth.py,sha256=tPipbOtHnsrvJ-OUOE-lyfvvIhkTIGYlkgS81hLdyB8,783
 meshagent/cli/auth_async.py,sha256=mi2-u949M412PAMN-PCdHEiF9hGf0W3m1RAseZX07-w,4058
-meshagent/cli/call.py,sha256=CMPMHbMtsXqFbekuo2ZgupSzXvnKrODBaf2bZugW0yc,4646
+meshagent/cli/call.py,sha256=aVRs-7QDZWxK8jYc71oACNIkHuoDe1KUyfl8EtUbj-0,5306
 meshagent/cli/chatbot.py,sha256=pK-_G3CiMbV-NC0iXzbjztu4f-ZAeXNzcmOB-HxJWQo,7928
-meshagent/cli/cli.py,sha256=D2cIVAgYZ095XqWBrvd7Qq60yGL7pfLTIK4Y52xrKSM,6314
+meshagent/cli/cli.py,sha256=Xltp1pICOdWEoCexeZz1taHPcRhRv7dM2e7tktyrd2k,6376
 meshagent/cli/cli_mcp.py,sha256=BTTAMn3u4i1uTDItFxmxMTsSAvFaWtdI3YdZngHz11g,10641
 meshagent/cli/cli_secrets.py,sha256=lkfR8tVjOA5KdynAhKCg5Z2EJkgrHFTX43pdB60YiU4,13767
 meshagent/cli/developer.py,sha256=JWz-qcduCbFopQ1DNGbwrknzFt59KBLIXx8DyD6PxZM,3081
+meshagent/cli/exec.py,sha256=46OyTVr3ejfDuNjBKkV9vkk62O808isD7bEC6jUgQHc,11338
 meshagent/cli/helper.py,sha256=gbd6Tvlp7CObPp3srWm-mbAe7tBD0iacg6PitGWJdtw,4874
 meshagent/cli/messaging.py,sha256=cr-oVAu_s8uEPUm3GELSq8yaVDnEWlt02D5V4KbA6wc,6437
 meshagent/cli/otel.py,sha256=1yoMGivskLV9f7M_LqCLKbttTTAPmFY5yhWXqFzvRN8,4066
 meshagent/cli/participant_token.py,sha256=N07hblRjj0zDKxl5CQXJjIMmft5s9mWgKZKz-VZyhKw,1400
 meshagent/cli/projects.py,sha256=WaO7M-D4ghy0nVpvwZ08ZEcybZ_e_cFe6rEoNxyAWkc,3306
-meshagent/cli/services.py,sha256=og4iOwxIT-TgYtTBExGbrABQJva9yo5PjeD_eFLw6dU,11358
+meshagent/cli/services.py,sha256=1afeMH41Kj0-1uAKB72buWnPFcgaqT4xFVO4FEpTPC0,19308
 meshagent/cli/sessions.py,sha256=MP7XhrtkUrealdpl8IKrTR3u9sjF15sG175-Y_m7nps,800
-meshagent/cli/storage.py,sha256=Q3ajuC6j4GLlU4jZoUW_Zsl1dOr04vzLibw2DPedJJ4,35564
-meshagent/cli/tty.py,sha256=GBVz5XoAKTCoczMnnJrLLmQiAHTvHE6HYxxSYfw-UZc,3988
-meshagent/cli/version.py,sha256=rFnu2wT8xSk2KNzRssUju1l870Gz9DdJMfBB8jhzzO0,23
+meshagent/cli/storage.py,sha256=wtLKYFyfsErCePxCG962Xb--moCN-zj9uVCtRPhIpfA,35572
+meshagent/cli/version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
 meshagent/cli/voicebot.py,sha256=Ykn9mUhcwl03ZCPDRua6moeNyrvToGPowQfjhPM0zqA,5032
 meshagent/cli/webhook.py,sha256=r5zct-UBQYSq3BWmnZRrHVOEHVlkY0j8uDxGVn3Pbxo,2902
-meshagent_cli-0.0.39.dist-info/METADATA,sha256=_sxxWGR7Cs7cYU_dIPCNOiy0hnIzN4abrkT2b8YkPNA,1338
-meshagent_cli-0.0.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-meshagent_cli-0.0.39.dist-info/entry_points.txt,sha256=WRcGGN4vMtvC5Pgl3uRFqsJiQXNoHuLLa-TCSY3gAhQ,52
-meshagent_cli-0.0.39.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
-meshagent_cli-0.0.39.dist-info/RECORD,,
+meshagent_cli-0.2.0.dist-info/METADATA,sha256=vGR8j-Ajp6FtL4PXzzGfh_0-mMN17HOuXO6QM_dQLj8,1448
+meshagent_cli-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+meshagent_cli-0.2.0.dist-info/entry_points.txt,sha256=WRcGGN4vMtvC5Pgl3uRFqsJiQXNoHuLLa-TCSY3gAhQ,52
+meshagent_cli-0.2.0.dist-info/top_level.txt,sha256=GlcXnHtRP6m7zlG3Df04M35OsHtNXy_DY09oFwWrH74,10
+meshagent_cli-0.2.0.dist-info/RECORD,,

meshagent/cli/tty.py

@@ -1,118 +0,0 @@
-import sys
-import tty
-import termios
-from meshagent.api.helpers import websocket_room_url
-from typing import Annotated, Optional
-
-import asyncio
-import typer
-from rich import print
-import aiohttp
-
-from meshagent.api import ParticipantToken
-from meshagent.cli import async_typer
-from meshagent.cli.helper import (
-    get_client,
-    resolve_project_id,
-    resolve_api_key,
-)
-
-
-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)
-
-        token = ParticipantToken(
-            name="tty", 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.add_role_grant(role="user")
-        token.add_room_grant(room)
-
-        ws_url = (
-            websocket_room_url(room_name=room) + f"/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()