meshagent-cli 0.5.18__py3-none-any.whl → 0.6.0__py3-none-any.whl

meshagent/cli/exec.py

@@ -1,11 +1,10 @@
 import sys
-import tty as _tty
-import termios
+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, ApiKeyIdOption, RoomOption
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
 import asyncio
 import typer
 from rich import print
@@ -15,18 +14,69 @@ import signal
 import shutil
 import json
 from urllib.parse import quote
+import threading
+import time
 
-from meshagent.api import ParticipantToken
 
 import logging
 
 from meshagent.cli.helper import (
     get_client,
     resolve_project_id,
-    resolve_api_key,
     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")
@@ -36,7 +86,6 @@ def register(app: typer.Typer):
         room: RoomOption,
         name: Annotated[Optional[str], typer.Option()] = None,
         image: Annotated[Optional[str], typer.Option()] = None,
-        api_key_id: ApiKeyIdOption = None,
         command: Annotated[list[str], typer.Argument(...)] = None,
         tty: bool = False,
         room_storage_path: str = "/data",
@@ -45,27 +94,12 @@ def register(app: typer.Typer):
         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
-            )
             room = resolve_room(room)
 
-            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)
+            connection = await client.connect_room(project_id=project_id, room=room)
 
             ws_url = (
-                websocket_room_url(room_name=room)
-                + f"/exec?token={token.to_jwt(token=key)}"
+                websocket_room_url(room_name=room) + f"/exec?token={connection.jwt}"
             )
 
             if image:
@@ -98,13 +132,12 @@ def register(app: typer.Typer):
 
             if tty:
                 # Save current terminal settings so we can restore them later.
-                old_tty_settings = termios.tcgetattr(sys.stdin)
-                _tty.setraw(sys.stdin)
+                old_tty_settings = set_raw(sys.stdin)
 
             async with RoomClient(
                 protocol=WebSocketClientProtocol(
                     url=websocket_room_url(room_name=room),
-                    token=token.to_jwt(token=key),
+                    token=connection.jwt,
                 )
             ):
                 try:
@@ -113,25 +146,29 @@ def register(app: typer.Typer):
                             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
-                            )
+                            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
-                            )
+                                (
+                                    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:
@@ -206,46 +243,97 @@ def register(app: typer.Typer):
 
                                 task.add_done_callback(on_done)
 
-                            loop.add_signal_handler(signal.SIGWINCH, on_sigwinch)
+                            if hasattr(signal, "SIGWINCH"):
+                                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
-                                )
+                                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:
 
-                                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,
+                                        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
                                     )
 
-                                    first = done.pop()
-                                    if first == websocket_recv_task:
-                                        break
-
-                                    data = first.result()
-                                    if not data:
-                                        break
+                                    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
 
-                                    if websocket.closed:
-                                        break
+                                        data = first.result()
+                                        if not data:
+                                            break
 
-                                    if tty:
-                                        if data == b"\x04":
+                                        if websocket.closed:
                                             break
 
-                                    if data:
-                                        send_queue.put_nowait(b"\0" + data)
-                                    else:
-                                        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")
 
@@ -283,9 +371,7 @@ def register(app: typer.Typer):
                 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
-                        )
+                        restore(sys.stdin, old_tty_settings)
 
         except Exception as e:
             print(f"[red]{e}[/red]")

meshagent/cli/helper.py

@@ -7,10 +7,9 @@ from typing import Optional
 from meshagent.cli import auth_async
 from meshagent.cli import async_typer
 from meshagent.api.helpers import meshagent_base_url
-from meshagent.api.accounts_client import AccountsClient
-from meshagent.api.participant_token import ParticipantToken
-
+from meshagent.api.client import Meshagent
 import os
+from rich import print
 
 SETTINGS_FILE = Path.home() / ".meshagent" / "project.json"
 
@@ -50,25 +49,38 @@ async def set_active_project(project_id: str | None):
     _save_settings(settings)
 
 
-async def get_active_api_key(project_id: str):
+async def set_active_api_key(project_id: str, key: str):
     settings = _load_settings()
-    if settings is None:
-        return None
-    return settings.active_api_keys.get(project_id, None)
+    settings.active_api_keys[project_id] = key
+    _save_settings(settings)
 
 
-async def set_active_api_key(project_id: str, api_key_id: str | None):
+async def get_active_api_key(project_id: str):
     settings = _load_settings()
-    settings.active_api_keys[project_id] = api_key_id
-    _save_settings(settings)
+    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()
 
 
 async def get_client():
-    access_token = await auth_async.get_access_token()
-    return AccountsClient(base_url=meshagent_base_url(), token=access_token)
+    key = os.getenv("MESHAGENT_API_KEY")
+    if key is not None:
+        return Meshagent(
+            base_url=meshagent_base_url(),
+            token=key,
+        )
+    else:
+        access_token = await auth_async.get_access_token()
+        return Meshagent(
+            base_url=meshagent_base_url(),
+            token=access_token,
+        )
 
 
 def print_json_table(records: list, *cols):
@@ -118,62 +130,18 @@ async def resolve_project_id(project_id: Optional[str] = None):
     return project_id
 
 
-async def resolve_api_key(project_id: str, api_key_id: Optional[str] = None):
-    if api_key_id is None:
-        api_key_id = await get_active_api_key(project_id=project_id)
+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 api_key_id is None:
+    if key is None:
         print(
-            "[red]API Key ID not specified, activate an api key or pass an api key id on the command line[/red]"
+            "[red]--key is required if MESHGENT_API_KEY is not set. You can use meshagent api-key create to create a new api key."
         )
-        raise typer.Exit(code=1)
+        raise typer.Exit(1)
 
-    return api_key_id
-
-
-async def resolve_token_jwt(
-    *,
-    project_id: str,
-    api_key_id: Optional[str] = None,
-    token_path: Optional[str] = None,
-    name: Optional[str] = None,
-    role: Optional[str] = None,
-    room: Optional[str] = None,
-) -> str:
-    jwt = None
-
-    if api_key_id is None:
-        if token_path is not None:
-            if token_path is None:
-                token_path = os.getenv(
-                    "MESHAGENT_TOKEN_PATH",
-                    (Path.home() / ".meshagent" / "token").as_posix(),
-                )
-
-            p = Path(token_path)
-            jwt = p.read_text().strip()
-
-        else:
-            jwt = os.getenv("MESHAGENT_TOKEN", None)
-
-    if jwt is None:
-        account_client = await get_client()
-        try:
-            key = (
-                await account_client.decrypt_project_api_key(
-                    project_id=project_id, id=api_key_id
-                )
-            )["token"]
-
-            token = ParticipantToken(
-                name=name, project_id=project_id, api_key_id=api_key_id
-            )
-
-            token.add_role_grant(role=role)
-            token.add_room_grant(room)
-
-            jwt = token.to_jwt(token=key)
-        finally:
-            await account_client.close()
-
-    return jwt
+    return key

meshagent/cli/helpers.py

@@ -0,0 +1,131 @@
+from meshagent.cli import async_typer
+
+
+from meshagent.api import SchemaRegistry, SchemaRegistration
+
+
+import logging
+
+app = async_typer.AsyncTyper(help="Join a mailbot to a room")
+
+
+@app.async_command("service")
+async def helpers_service():
+    from meshagent.agents.planning import DynamicPlanningResponder, PlanningResponder
+    from meshagent.openai.tools import OpenAIResponsesAdapter
+    from meshagent.tools.storage import StorageToolkit
+    from meshagent.api.services import ServiceHost
+
+    from meshagent.agents.schemas.gallery import gallery_schema
+    from meshagent.agents.schemas.document import document_schema
+    from meshagent.agents.schemas.transcript import transcript_schema
+    from meshagent.agents.schemas.super_editor_document import (
+        super_editor_document_schema,
+    )
+    from meshagent.agents.schemas.presentation import presentation_schema
+    from meshagent.agents import thread_schema
+
+    logging.getLogger("openai").setLevel(logging.ERROR)
+    logging.getLogger("httpx").setLevel(logging.ERROR)
+
+    service = ServiceHost(port=9000)
+
+    @service.path("/planner")
+    class Planner(PlanningResponder):
+        def __init__(self, **kwargs):
+            super().__init__(
+                name="meshagent.planner",
+                title="Generic Task Runner",
+                description="an agent that will perform a task with the selected tools",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-4.1"),
+                supports_tools=True,
+                input_prompt=True,
+                output_schema={
+                    "type": "object",
+                    "required": ["result"],
+                    "additionalProperties": False,
+                    "properties": {"result": {"type": "string"}},
+                },
+            )
+
+    @service.path("/schema_planner")
+    class DynamicPlanner(DynamicPlanningResponder):
+        def __init__(self, **kwargs):
+            super().__init__(
+                name="meshagent.schema_planner",
+                title="Schema Task Runner",
+                description="an agent that can produces output that matches a schema",
+                llm_adapter=OpenAIResponsesAdapter(model="gpt-4.1"),
+            )
+
+    @service.path("/schemas/document")
+    class DocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "document"
+            schema = document_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/superdoc")
+    class SuperdocDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "superdoc"
+            schema = super_editor_document_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/gallery")
+    class GalleryDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "gallery"
+            schema = gallery_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/thread")
+    class ThreadDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "thread"
+            schema = thread_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/presentation")
+    class PresentationDocumentSchemaRegistry(SchemaRegistry):
+        def __init__(presentation):
+            name = "presentation"
+            schema = presentation_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/schemas/transcript")
+    class TranscriptRegistry(SchemaRegistry):
+        def __init__(self):
+            name = "transcript"
+            schema = transcript_schema
+            super().__init__(
+                name=f"meshagent.schema.{name}",
+                validate_webhook_secret=False,
+                schemas=[SchemaRegistration(name=name, schema=schema)],
+            )
+
+    @service.path("/toolkits/storage")
+    class HostedStorageToolkit(StorageToolkit):
+        pass
+
+    await service.run()