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

meshagent/cli/helper.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel
 from pathlib import Path
 from typing import Optional
 
-from meshagent.cli import auth_async 
+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
@@ -15,27 +15,32 @@ import os
 
 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():
     _ensure_cache_dir()
     if SETTINGS_FILE.exists():
         return Settings.model_validate_json(SETTINGS_FILE.read_text())
-    
+
     return Settings()
 
+
 async def get_active_project():
     settings = _load_settings()
-    if settings == None:
+    if settings is None:
         return None
     return settings.active_project
 
@@ -45,9 +50,10 @@ async def set_active_project(project_id: str | None):
     settings.active_project = project_id
     _save_settings(settings)
 
+
 async def get_active_api_key(project_id: str):
     settings = _load_settings()
-    if settings == None:
+    if settings is None:
         return None
     return settings.active_api_keys.get(project_id, None)
 
@@ -60,12 +66,13 @@ async def set_active_api_key(project_id: str, api_key_id: str | 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)
 
+
 def print_json_table(records: list, *cols):
-    
     if not records:
         raise SystemExit("No rows to print")
 
@@ -75,7 +82,7 @@ def print_json_table(records: list, *cols):
     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"
+            table.add_column(col.title())  # "id" → "Id"
 
         for row in records:
             table.add_row(*(str(row.get(col, "")) for col in cols))
@@ -83,7 +90,7 @@ def print_json_table(records: list, *cols):
     else:
         # use the keys of the first object as column order
         for col in records[0]:
-            table.add_column(col.title())               # "id" → "Id"
+            table.add_column(col.title())  # "id" → "Id"
 
         for row in records:
             table.add_row(*(str(row.get(col, "")) for col in records[0]))
@@ -93,60 +100,74 @@ def print_json_table(records: list, *cols):
 
 
 def resolve_room(room_name: Optional[str] = None):
-    if room_name == 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 == None: 
+    if project_id is None:
         project_id = await get_active_project()
-    
-    if project_id == None:
-        print("[red]Project ID not specified, activate a project or pass a project on the command line[/red]")
+
+    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 resolve_api_key(project_id: str, api_key_id: Optional[str] = None):
-    if api_key_id == None: 
+    if api_key_id is None:
         api_key_id = await get_active_api_key(project_id=project_id)
-    
-    if api_key_id == None:
-        print("[red]API Key ID not specified, activate an api key or pass an api key id on the command line[/red]")
+
+    if api_key_id is None:
+        print(
+            "[red]API Key ID not specified, activate an api key or pass an api key id on the command line[/red]"
+        )
         raise typer.Exit(code=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
+    return api_key_id
 
-    if api_key_id == None:
-        
-        if token_path != None:
 
-            if token_path == None:
+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
 
-                token_path = os.getenv("MESHAGENT_TOKEN_PATH", (Path.home() / ".meshagent" / "token").as_posix())
+    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:
 
+        else:
             jwt = os.getenv("MESHAGENT_TOKEN", None)
 
-    if jwt == 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"]
+            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
+                name=name, project_id=project_id, api_key_id=api_key_id
             )
 
             token.add_role_grant(role=role)
@@ -154,7 +175,6 @@ async def resolve_token_jwt(*, project_id: str, api_key_id: Optional[str] = None
 
             jwt = token.to_jwt(token=key)
         finally:
-
             await account_client.close()
 
     return jwt

meshagent/cli/messaging.py

@@ -3,10 +3,16 @@ from rich import print
 from typing import Annotated, Optional
 import json
 
-from meshagent.api import RoomClient, ParticipantToken, WebSocketClientProtocol
+from meshagent.api import RoomClient, WebSocketClientProtocol
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, resolve_project_id, resolve_api_key, resolve_token_jwt, resolve_room
+from meshagent.cli.helper import (
+    get_client,
+    resolve_project_id,
+    resolve_api_key,
+    resolve_token_jwt,
+    resolve_room,
+)
 
 app = async_typer.AsyncTyper()
 
@@ -16,10 +22,10 @@ async def messaging_list_participants_command(
     *,
     project_id: str = None,
     room: Annotated[Optional[str], typer.Option()] = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
-    role: str = "user"
+    role: str = "user",
 ):
     """
     List all messaging-enabled participants in the room.
@@ -29,19 +35,25 @@ async def messaging_list_participants_command(
         # Resolve project_id if not provided
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
-        
+
         room = resolve_room(room)
-        
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt
+                token=jwt,
             )
         ) as client:
-
             # Must enable before we can see who else is enabled
             await client.messaging.enable()
             await client.messaging.start()
@@ -49,11 +61,7 @@ async def messaging_list_participants_command(
             participants = client.messaging.get_participants()
             output = []
             for p in participants:
-                output.append({
-                    "id": p.id,
-                    "role": p.role,
-                    "attributes": p._attributes
-                })
+                output.append({"id": p.id, "role": p.role, "attributes": p._attributes})
 
             print(json.dumps(output, indent=2))
 
@@ -68,11 +76,13 @@ async def messaging_send_command(
     *,
     project_id: str = None,
     room: Annotated[Optional[str], typer.Option()] = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
     role: str = "user",
-    to_participant_id: Annotated[str, typer.Option(..., help="Participant ID to send a message to")],
+    to_participant_id: Annotated[
+        str, typer.Option(..., help="Participant ID to send a message to")
+    ],
     data: Annotated[str, typer.Option(..., help="JSON message to send")],
 ):
     """
@@ -83,16 +93,23 @@ async def messaging_send_command(
         # Resolve project_id if not provided
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id, api_key_id)
-        
+
         room = resolve_room(room)
-        
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt
+                token=jwt,
             )
         ) as client:
             # Create and enable messaging
@@ -105,16 +122,18 @@ async def messaging_send_command(
                 if p.id == to_participant_id:
                     participant = p
                     break
-            
+
             if participant is None:
-                print(f"[bold red]Participant with ID {to_participant_id} not found or not messaging-enabled.[/bold red]")
+                print(
+                    f"[bold red]Participant with ID {to_participant_id} not found or not messaging-enabled.[/bold red]"
+                )
             else:
                 # Send the message
                 await client.messaging.send_message(
                     to=participant,
                     type="chat.message",
                     message=json.loads(data),
-                    attachment=None
+                    attachment=None,
                 )
                 print("[bold cyan]Message sent successfully.[/bold cyan]")
 
@@ -123,17 +142,16 @@ async def messaging_send_command(
         await account_client.close()
 
 
-
 @app.async_command("broadcast")
 async def messaging_broadcast_command(
     *,
     project_id: str = None,
     room: Annotated[Optional[str], typer.Option()] = None,
-    token_path: Annotated[Optional[str], typer.Option()] = None, 
+    token_path: Annotated[Optional[str], typer.Option()] = None,
     api_key_id: Annotated[Optional[str], typer.Option()] = None,
     name: Annotated[str, typer.Option()] = "cli",
     role: str = "user",
-    data: Annotated[str, typer.Option(..., help="JSON message to broadcast")]
+    data: Annotated[str, typer.Option(..., help="JSON message to broadcast")],
 ):
     """
     Broadcast a message to all messaging-enabled participants in the room.
@@ -145,13 +163,20 @@ async def messaging_broadcast_command(
         api_key_id = await resolve_api_key(project_id, api_key_id)
 
         room = resolve_room(room)
-        jwt = await resolve_token_jwt(project_id=project_id, api_key_id=api_key_id, token_path=token_path, name=name, role=role, room=room)
+        jwt = await resolve_token_jwt(
+            project_id=project_id,
+            api_key_id=api_key_id,
+            token_path=token_path,
+            name=name,
+            role=role,
+            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=jwt
+                token=jwt,
             )
         ) as client:
             # Create and enable messaging
@@ -160,9 +185,7 @@ async def messaging_broadcast_command(
 
             # Broadcast the message
             await client.messaging.broadcast_message(
-                type="chat.broadcast",
-                message=json.loads(data),
-                attachment=None
+                type="chat.broadcast", message=json.loads(data), attachment=None
             )
             print("[bold cyan]Broadcast message sent successfully.[/bold cyan]")
 

meshagent/cli/otel.py

@@ -8,8 +8,11 @@ from opentelemetry import metrics
 from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
 from opentelemetry.sdk._logs.export import ConsoleLogExporter
 from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader, ConsoleMetricExporter
-from opentelemetry import _logs  
+from opentelemetry.sdk.metrics.export import (
+    PeriodicExportingMetricReader,
+    ConsoleMetricExporter,
+)
+from opentelemetry import _logs
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
@@ -19,6 +22,7 @@ import logging
 
 import os
 
+
 def _call_once(fn):
     called = False
     result = None
@@ -29,6 +33,7 @@ def _call_once(fn):
             result = fn(*args, **kwargs)
             called = True
         return result
+
     return wrapper
 
 
@@ -36,13 +41,13 @@ attributes = {
     SERVICE_NAME: "room-server",
 }
 
-if os.getenv("MESHAGENT_PROJECT_ID") != None:
+if os.getenv("MESHAGENT_PROJECT_ID") is not None:
     attributes["project"] = os.getenv("MESHAGENT_PROJECT_ID")
 
-if os.getenv("MESHAGENT_SESSION_ID") != None:
+if os.getenv("MESHAGENT_SESSION_ID") is not None:
     attributes["session"] = os.getenv("MESHAGENT_SESSION_ID")
 
-if os.getenv("MESHAGENT_ROOM") != None:
+if os.getenv("MESHAGENT_ROOM") is not None:
     attributes["room"] = os.getenv("MESHAGENT_ROOM")
 
 resource = Resource.create(attributes=attributes)
@@ -53,66 +58,65 @@ meter_provider = None
 
 add_console_exporters = False
 
-otel_endpoint = os.getenv("OTEL_ENDPOINT") 
-
-if otel_endpoint != None:
+otel_endpoint = os.getenv("OTEL_ENDPOINT")
 
+if otel_endpoint is not None:
     otel_logs_endpoint = otel_endpoint + "/v1/logs"
     otel_traces_endpoint = otel_endpoint + "/v1/traces"
     otel_metrics_endpoint = otel_endpoint + "/v1/metrics"
-    
-    if otel_logs_endpoint != None:
+
+    if otel_logs_endpoint is not None:
         logs_exporter = OTLPLogExporter(
             endpoint=otel_logs_endpoint,
         )
         logger_provider = LoggerProvider(resource=resource)
-        _logs.set_logger_provider(logger_provider) 
-        
-        logger_provider.add_log_record_processor(
-            BatchLogRecordProcessor(logs_exporter)
-        )
+        _logs.set_logger_provider(logger_provider)
 
-        if add_console_exporters: 
-            logger_provider.add_log_record_processor(BatchLogRecordProcessor(ConsoleLogExporter()))
+        logger_provider.add_log_record_processor(BatchLogRecordProcessor(logs_exporter))
 
-        
-    if otel_traces_endpoint != None:
+        if add_console_exporters:
+            logger_provider.add_log_record_processor(
+                BatchLogRecordProcessor(ConsoleLogExporter())
+            )
+
+    if otel_traces_endpoint is not None:
         tracer_provider = TracerProvider(resource=resource)
         processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=otel_traces_endpoint))
         tracer_provider.add_span_processor(processor)
-        if add_console_exporters: 
-            tracer_provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+        if add_console_exporters:
+            tracer_provider.add_span_processor(
+                BatchSpanProcessor(ConsoleSpanExporter())
+            )
         trace.set_tracer_provider(tracer_provider)
 
-    if otel_metrics_endpoint != None:
+    if otel_metrics_endpoint is not None:
         reader = PeriodicExportingMetricReader(
             exporter=OTLPMetricExporter(
                 endpoint=otel_metrics_endpoint,
-                 preferred_temporality={
+                preferred_temporality={
                     Counter: AggregationTemporality.DELTA,
                     Histogram: AggregationTemporality.DELTA,
                 },
             ),
-            export_interval_millis=1000
+            export_interval_millis=1000,
         )
-        
+
         readers = [
             reader,
         ]
         if add_console_exporters:
-            readers.append(PeriodicExportingMetricReader(
-                ConsoleMetricExporter()
-            ))
-        
+            readers.append(PeriodicExportingMetricReader(ConsoleMetricExporter()))
+
         meter_provider = MeterProvider(resource=resource, metric_readers=readers)
         metrics.set_meter_provider(meter_provider)
 
+
 @_call_once
 def init(level):
-    if logger_provider != None:
+    if logger_provider is not None:
         logging_handler = LoggingHandler(level=level, logger_provider=logger_provider)
-        root = logging.getLogger() 
-        root.setLevel(level) 
+        root = logging.getLogger()
+        root.setLevel(level)
         root.addHandler(logging_handler)
     else:
         logging.basicConfig(level=level)

meshagent/cli/participant_token.py

@@ -1,40 +1,49 @@
 import typer
 from rich import print
 from typing import Annotated, Optional
-from meshagent.api import RoomClient, ParticipantToken
-from meshagent.cli.helper import set_active_project, get_active_project, resolve_project_id, resolve_api_key
+from meshagent.api import ParticipantToken
+from meshagent.cli.helper import resolve_project_id, resolve_api_key
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, print_json_table, set_active_project, resolve_project_id
+from meshagent.cli.helper import get_client
 import pathlib
 
 app = async_typer.AsyncTyper()
 
+
 @app.async_command("generate")
-async def generate(*, project_id: str = None, token_path: Annotated[str, typer.Option()], room: Annotated[str, typer.Option()], api_key_id: Annotated[Optional[str], typer.Option()] = None, name: Annotated[str, typer.Option()], role: str = "agent"):
+async def generate(
+    *,
+    project_id: str = None,
+    token_path: Annotated[str, typer.Option()],
+    room: Annotated[str, typer.Option()],
+    api_key_id: Annotated[Optional[str], typer.Option()] = None,
+    name: Annotated[str, typer.Option()],
+    role: str = "agent",
+):
     client = await get_client()
     try:
         project_id = await resolve_project_id(project_id=project_id)
         api_key_id = await resolve_api_key(project_id=project_id, api_key_id=api_key_id)
 
-        key = (await client.decrypt_project_api_key(project_id=project_id, id=api_key_id))["token"]
+        key = (
+            await 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
+            name=name, project_id=project_id, api_key_id=api_key_id
         )
 
         token.add_role_grant(role=role)
 
         token.add_room_grant(room)
 
-        if token_path == None:
-
+        if token_path is None:
             print(token.to_jwt(token=key))
 
         else:
+            pathlib.Path(token_path).expanduser().resolve().write_text(
+                token.to_jwt(token=key)
+            )
 
-            pathlib.Path(token_path).expanduser().resolve().write_text(token.to_jwt(token=key))
-    
     finally:
         await client.close()

meshagent/cli/projects.py

@@ -16,10 +16,11 @@ async def create(name: str):
     client = await get_client()
     try:
         result = await client.create_project(name)
-        print(f"[green]Project created:[/] {result["id"]}")
+        print(f"[green]Project created:[/] {result['id']}")
     finally:
         await client.close()
 
+
 @app.async_command("list")
 async def list():
     client = await get_client()
@@ -32,6 +33,7 @@ async def list():
     print_json_table(projects["projects"], "id", "name")
     await client.close()
 
+
 @app.async_command("activate")
 async def activate(
     project_id: str | None = typer.Argument(None),
@@ -95,4 +97,3 @@ async def activate(
             raise typer.Exit(code=1)
     finally:
         await client.close()
-