meshagent-cli 0.22.2__py3-none-any.whl

meshagent/cli/developer.py

@@ -0,0 +1,70 @@
+import asyncio
+import json
+from rich import print
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+from meshagent.cli import async_typer
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+)
+from meshagent.api import (
+    RoomClient,
+    WebSocketClientProtocol,
+)
+from meshagent.api.helpers import meshagent_base_url, websocket_room_url
+
+app = async_typer.AsyncTyper(help="Developer utilities for a room")
+
+
+@app.async_command("watch", help="Stream developer logs from a room")
+async def watch_logs(
+    *,
+    project_id: ProjectIdOption,
+    room: RoomOption,
+):
+    """
+    Watch logs from the developer feed in the specified room.
+    """
+
+    account_client = await get_client()
+    try:
+        # Resolve project ID (or fetch from the active project if not provided)
+        project_id = await resolve_project_id(project_id=project_id)
+        room = resolve_room(room)
+
+        connection = await account_client.connect_room(project_id=project_id, 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=connection.jwt,
+            )
+        ) as client:
+            # Create a developer client from the room client
+
+            # Define how to handle the incoming log events
+            def handle_log(type: str, data: dict):
+                # You can customize this print to suit your needs
+                print(f"[magenta]{type}[/magenta]: {json.dumps(data, indent=2)}")
+
+            # Attach our handler to the "log" event
+            client.developer.on("log", handle_log)
+
+            # Enable watching
+            await client.developer.enable()
+            print("[bold cyan]watching enabled. Press Ctrl+C to stop.[/bold cyan]")
+
+            try:
+                # Block forever, until Ctrl+C
+                while True:
+                    await asyncio.sleep(10)
+            except KeyboardInterrupt:
+                print("[bold red]Stopping watch...[/bold red]")
+            finally:
+                # Disable watching before exiting
+                await client.developer.disable()
+
+    finally:
+        await account_client.close()

meshagent/cli/exec.py

@@ -0,0 +1,397 @@
+import sys
+import os
+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
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
+import asyncio
+import typer
+from rich import print
+import aiohttp
+import struct
+import signal
+import shutil
+import json
+from urllib.parse import quote
+import threading
+import time
+
+
+import logging
+
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_room,
+)
+
+if os.name == "nt":
+    import msvcrt
+    import ctypes
+    from ctypes import wintypes
+
+    _kernel32 = ctypes.windll.kernel32
+    _ENABLE_ECHO_INPUT = 0x0004
+    _ENABLE_LINE_INPUT = 0x0002
+
+    def set_raw(f):
+        """Disable line and echo mode for the given file handle."""
+        handle = msvcrt.get_osfhandle(f.fileno())
+        original_mode = wintypes.DWORD()
+        if not _kernel32.GetConsoleMode(handle, ctypes.byref(original_mode)):
+            return None
+        new_mode = original_mode.value & ~(_ENABLE_ECHO_INPUT | _ENABLE_LINE_INPUT)
+        _kernel32.SetConsoleMode(handle, new_mode)
+        return handle, original_mode.value
+
+    def restore(f, state):
+        if state is None:
+            return None
+        handle, mode = state
+        _kernel32.SetConsoleMode(handle, mode)
+        return None
+
+else:
+    import termios
+    import tty as _tty
+
+    def set_raw(fd):
+        old = termios.tcgetattr(fd)
+        _tty.setraw(fd)
+        return old
+
+    def restore(fd, old_settings):
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+class _StdWriter:
+    """Simple asyncio-friendly wrapper for standard streams on Windows."""
+
+    def __init__(self, file):
+        self._file = file
+
+    def write(self, data: bytes) -> None:
+        self._file.buffer.write(data)
+
+    async def drain(self) -> None:
+        await asyncio.get_running_loop().run_in_executor(None, self._file.flush)
+
+
+def register(app: typer.Typer):
+    @app.async_command("exec")
+    async def exec_command(
+        *,
+        project_id: ProjectIdOption,
+        room: RoomOption,
+        name: Annotated[
+            Optional[str], typer.Option(help="Optional exec session name")
+        ] = None,
+        image: Annotated[
+            Optional[str],
+            typer.Option(help="Optional container image to use for the exec session"),
+        ] = None,
+        command: Annotated[
+            list[str],
+            typer.Argument(..., help="Command to execute (omit when using `--tty`)"),
+        ] = None,
+        tty: Annotated[
+            bool,
+            typer.Option(
+                "--tty/--no-tty",
+                help="Allocate an interactive TTY (requires a real terminal)",
+            ),
+        ] = False,
+        room_storage_path: Annotated[
+            str, typer.Option(help="Room storage mount path (default: /data)")
+        ] = "/data",
+    ):
+        """Open an interactive websocket‑based TTY."""
+        client = await get_client()
+        try:
+            project_id = await resolve_project_id(project_id=project_id)
+            room = resolve_room(room)
+
+            connection = await client.connect_room(project_id=project_id, room=room)
+
+            ws_url = (
+                websocket_room_url(room_name=room) + f"/exec?token={connection.jwt}"
+            )
+
+            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 room_storage_path:
+                room_storage_path += (
+                    f"&room_storage_path={quote(' '.join(room_storage_path))}"
+                )
+
+            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 = set_raw(sys.stdin)
+
+            async with RoomClient(
+                protocol=WebSocketClientProtocol(
+                    url=websocket_room_url(room_name=room),
+                    token=connection.jwt,
+                )
+            ):
+                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()
+                            if os.name == "nt":
+                                stdout_writer = _StdWriter(sys.stdout)
+                                stderr_writer = _StdWriter(sys.stderr)
+                            else:
+                                (
+                                    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)
+
+                            if hasattr(signal, "SIGWINCH"):
+                                loop.add_signal_handler(signal.SIGWINCH, on_sigwinch)
+
+                            async def read_stdin():
+                                loop = asyncio.get_running_loop()
+
+                                if os.name == "nt":
+                                    queue: asyncio.Queue[bytes] = asyncio.Queue()
+                                    stop_event = threading.Event()
+
+                                    if sys.stdin.isatty():
+
+                                        def reader() -> None:
+                                            try:
+                                                while not stop_event.is_set():
+                                                    if msvcrt.kbhit():
+                                                        data = msvcrt.getch()
+                                                        loop.call_soon_threadsafe(
+                                                            queue.put_nowait, data
+                                                        )
+                                                    else:
+                                                        time.sleep(0.01)
+                                            finally:
+                                                loop.call_soon_threadsafe(
+                                                    queue.put_nowait, b""
+                                                )
+                                    else:
+
+                                        def reader() -> None:
+                                            try:
+                                                while not stop_event.is_set():
+                                                    data = sys.stdin.buffer.read(1)
+                                                    loop.call_soon_threadsafe(
+                                                        queue.put_nowait, data
+                                                    )
+                                                    if not data:
+                                                        break
+                                            finally:
+                                                loop.call_soon_threadsafe(
+                                                    queue.put_nowait, b""
+                                                )
+
+                                    thread = threading.Thread(target=reader)
+                                    thread.start()
+
+                                    async def reader_task() -> bytes:
+                                        return await queue.get()
+                                else:
+                                    reader = asyncio.StreamReader()
+                                    protocol = asyncio.StreamReaderProtocol(reader)
+                                    await loop.connect_read_pipe(
+                                        lambda: protocol, sys.stdin
+                                    )
+
+                                    async def reader_task():
+                                        return await reader.read(1)
+
+                                try:
+                                    while True:
+                                        # Read one character at a time from stdin without blocking the event loop.
+                                        done, pending = await asyncio.wait(
+                                            [
+                                                asyncio.create_task(reader_task()),
+                                                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
+                                finally:
+                                    if os.name == "nt":
+                                        stop_event.set()
+                                        thread.join()
+
+                                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.
+                        restore(sys.stdin, 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/helper.py

@@ -0,0 +1,236 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from pydantic import BaseModel
+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.specs.service import ServiceSpec
+from meshagent.agents.context import AgentChatContext
+from meshagent.api.client import Meshagent, RoomConnectionInfo
+import os
+import aiofiles
+from pydantic_yaml import parse_yaml_raw_as
+import json
+
+from rich import print
+
+SETTINGS_FILE = Path.home() / ".meshagent" / "project.json"
+
+
+def _ensure_cache_dir():
+    SETTINGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+
+class Settings(BaseModel):
+    active_project: Optional[str] = None
+    active_api_keys: Optional[dict] = {}
+
+
+def _save_settings(s: Settings):
+    _ensure_cache_dir()
+    SETTINGS_FILE.write_text(s.model_dump_json())
+
+
+def _load_settings():
+    try:
+        _ensure_cache_dir()
+        if SETTINGS_FILE.exists():
+            return Settings.model_validate_json(SETTINGS_FILE.read_text())
+    except OSError as ex:
+        if ex.errno == 30:
+            return Settings()
+        else:
+            raise
+
+
+async def get_active_project():
+    settings = _load_settings()
+    if settings is None:
+        return None
+    return settings.active_project
+
+
+async def set_active_project(project_id: str | None):
+    settings = _load_settings()
+    settings.active_project = project_id
+    _save_settings(settings)
+
+
+async def set_active_api_key(project_id: str, key: str):
+    settings = _load_settings()
+    settings.active_api_keys[project_id] = key
+    _save_settings(settings)
+
+
+async def get_active_api_key(project_id: str):
+    settings = _load_settings()
+    if settings is None:
+        return None
+    key: str = settings.active_api_keys.get(project_id)
+    # Ignore old keys, API key format changed
+    if key is not None and key.startswith("ma-"):
+        return key
+    else:
+        return None
+
+
+app = async_typer.AsyncTyper()
+
+
+class CustomMeshagentClient(Meshagent):
+    async def connect_room(self, *, project_id: str, room: str) -> RoomConnectionInfo:
+        from urllib.parse import quote
+
+        jwt = os.getenv("MESHAGENT_TOKEN")
+
+        if jwt is not None and room == os.getenv("MESHAGENT_ROOM"):
+            return RoomConnectionInfo(
+                jwt=jwt,
+                room_name=room,
+                project_id=os.getenv("MESHAGENT_PROJECT_ID"),
+                room_url=meshagent_base_url() + f"/rooms/{quote(room)}",
+            )
+
+        return await super().connect_room(project_id=project_id, room=room)
+
+
+async def get_client():
+    key = os.getenv("MESHAGENT_API_KEY")
+    if key is not None or os.getenv("MESHAGENT_SESSION_ID") is not None:
+        return CustomMeshagentClient(
+            base_url=meshagent_base_url(),
+            token=key,
+        )
+    else:
+        access_token = await auth_async.get_access_token()
+        return CustomMeshagentClient(
+            base_url=meshagent_base_url(),
+            token=access_token,
+        )
+
+
+def print_json_table(records: list, *cols):
+    if not records:
+        raise SystemExit("No rows to print")
+
+    # 2️⃣  --- build the table -------------------------------------------
+    table = Table(show_header=True, header_style="bold magenta")
+
+    if len(cols) > 0:
+        # use the keys of the first object as column order
+        for col in cols:
+            table.add_column(col.title())  # "id" → "Id"
+
+        for row in records:
+            table.add_row(*(str(row.get(col, "")) for col in cols))
+
+    else:
+        # use the keys of the first object as column order
+        for col in records[0]:
+            table.add_column(col.title())  # "id" → "Id"
+
+        for row in records:
+            table.add_row(*(str(row.get(col, "")) for col in records[0]))
+
+    # 3️⃣  --- render ------------------------------------------------------
+    Console().print(table)
+
+
+def resolve_room(room_name: Optional[str] = None):
+    if room_name is None:
+        room_name = os.getenv("MESHAGENT_ROOM")
+
+    return room_name
+
+
+async def resolve_project_id(project_id: Optional[str] = None):
+    if project_id is None:
+        project_id = os.getenv("MESHAGENT_PROJECT_ID") or await get_active_project()
+
+    if project_id is None:
+        print(
+            "[red]Project ID not specified, activate a project or pass a project on the command line[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    return project_id
+
+
+async def init_context_from_spec(context: AgentChatContext) -> None:
+    path = os.getenv("MESHAGENT_SPEC_PATH")
+
+    if path is None:
+        return None
+
+    async with aiofiles.open(path, "r") as file:
+        spec_str = await file.read()
+        try:
+            json.loads(spec_str)
+            spec = ServiceSpec.model_validate_json(spec_str)
+        except ValueError:
+            # fallback on yaml parser if spec can't
+            spec = parse_yaml_raw_as(ServiceSpec, spec_str)
+
+        readme = spec.metadata.annotations.get("meshagent.service.readme")
+
+        if spec.metadata.description:
+            context.append_assistant_message(
+                f"This agent's description:\n{spec.metadata.description}"
+            )
+
+        if readme is not None:
+            context.append_assistant_message(f"This agent's README:\n{readme}")
+
+
+async def resolve_key(project_id: str | None, key: str | None):
+    project_id = await resolve_project_id(project_id=project_id)
+    if key is None:
+        key = await get_active_api_key(project_id=project_id)
+
+    if key is None:
+        key = os.getenv("MESHAGENT_API_KEY")
+
+    if key is None and os.getenv("MESHAGENT_TOKEN") is None:
+        print(
+            "[red]--key is required if MESHAGENT_API_KEY is not set. You can use meshagent api-key create to create a new api key."
+        )
+        raise typer.Exit(1)
+
+    return key
+
+
+def cleanup_args(args: list[str]):
+    out = []
+    i = 0
+    while i < len(args):
+        if args[i] == "--service-name":
+            i += 1
+        elif args[i] == "--service-title":
+            i += 1
+        elif args[i] == "--service-description":
+            i += 1
+        elif args[i] == "--project-id":
+            i += 1
+        elif args[i] == "--room":
+            i += 1
+        elif args[i].startswith("--service-name="):
+            pass
+        elif args[i].startswith("--service-title="):
+            pass
+        elif args[i].startswith("--service-description="):
+            pass
+        elif args[i].startswith("--project-id="):
+            pass
+        elif args[i].startswith("--room="):
+            pass
+        elif args[i] == "deploy":
+            pass
+        elif args[i] == "spec":
+            pass
+        else:
+            out.append(args[i])
+        i += 1
+    return out