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

meshagent/cli/agent.py

@@ -1,20 +1,19 @@
 import typer
 from rich import print
 from typing import Annotated, Optional
-from meshagent.cli.common_options import ProjectIdOption, ApiKeyIdOption, RoomOption
+from meshagent.cli.common_options import ProjectIdOption, RoomOption
 import json
 import asyncio
 
 from meshagent.api.helpers import meshagent_base_url, websocket_room_url
 from meshagent.api import (
     RoomClient,
-    ParticipantToken,
     WebSocketClientProtocol,
     RoomException,
 )
-from meshagent.cli.helper import resolve_project_id, resolve_api_key
+from meshagent.cli.helper import resolve_project_id
 from meshagent.cli import async_typer
-from meshagent.cli.helper import get_client, resolve_token_jwt, resolve_room
+from meshagent.cli.helper import get_client, resolve_room
 
 app = async_typer.AsyncTyper()
 
@@ -24,9 +23,6 @@ async def ask(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user",
     agent: Annotated[str, typer.Option()],
     input: Annotated[str, typer.Option()],
     timeout: Annotated[
@@ -39,27 +35,15 @@ async def ask(
     account_client = await get_client()
     try:
         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)
 
-        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)
+        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=token.to_jwt(token=key),
+                token=connection.jwt,
             )
         ) as client:
             found = timeout == 0
@@ -97,10 +81,6 @@ async def invoke_tool(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user",
     toolkit: Annotated[str, typer.Option(..., help="Toolkit name")],
     tool: Annotated[str, typer.Option(..., help="Tool name")],
     arguments: Annotated[
@@ -130,23 +110,15 @@ async def invoke_tool(
     account_client = await get_client()
     try:
         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,
-        )
+        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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             found = timeout == 0
@@ -194,10 +166,6 @@ async def list_agents_command(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
-    role: str = "user",
 ):
     """
     List all agents available in the room.
@@ -205,23 +173,15 @@ async def list_agents_command(
     account_client = await get_client()
     try:
         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,
-        )
+        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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             print("[bold green]Fetching list of agents...[/bold green]")
@@ -250,9 +210,6 @@ async def list_toolkits_command(
     *,
     project_id: ProjectIdOption = None,
     room: RoomOption,
-    token_path: Annotated[Optional[str], typer.Option()] = None,
-    api_key_id: ApiKeyIdOption = None,
-    name: Annotated[str, typer.Option(..., help="Participant name")] = "cli",
     role: str = "user",
     participant_id: Annotated[
         Optional[str], typer.Option(..., help="Optional participant ID")
@@ -264,22 +221,14 @@ async def list_toolkits_command(
     account_client = await get_client()
     try:
         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,
-        )
+        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=jwt,
+                token=connection.jwt,
             )
         ) as client:
             print("[bold green]Fetching list of toolkits...[/bold green]")

meshagent/cli/api_keys.py

@@ -1,4 +1,3 @@
-import typer
 import json
 from rich import print
 
@@ -11,7 +10,8 @@ from meshagent.cli.helper import (
     set_active_api_key,
 )
 from meshagent.cli.common_options import OutputFormatOption
-
+from typing import Annotated
+import typer
 
 app = async_typer.AsyncTyper(help="Manage or activate api-keys for your project")
 
@@ -24,7 +24,8 @@ async def list(
 ):
     project_id = await resolve_project_id(project_id=project_id)
     client = await get_client()
-    keys = (await client.list_project_api_keys(project_id=project_id))["keys"]
+    keys = (await client.list_api_keys(project_id=project_id))["keys"]
+
     if len(keys) > 0:
         if o == "json":
             sanitized_keys = [
@@ -40,110 +41,62 @@ async def list(
 
 @app.async_command("create")
 async def create(
-    *, project_id: ProjectIdOption = None, name: str, description: str = ""
+    *,
+    project_id: ProjectIdOption = None,
+    name: str,
+    description: Annotated[
+        str, typer.Option(..., help="a description for the api key")
+    ] = "",
+    activate: Annotated[
+        bool,
+        typer.Option(
+            ..., help="use this key by default for commands that accept an API key"
+        ),
+    ] = False,
+    silent: Annotated[bool, typer.Option(..., help="do not print api key")] = False,
 ):
     project_id = await resolve_project_id(project_id=project_id)
 
     client = await get_client()
-    api_key = await client.create_project_api_key(
+    api_key = await client.create_api_key(
         project_id=project_id, name=name, description=description
     )
-    print(api_key["token"])
-    await client.close()
-
-
-@app.async_command("delete")
-async def delete(*, project_id: ProjectIdOption = None, id: str):
-    project_id = await resolve_project_id(project_id=project_id)
+    if not silent:
+        if not activate:
+            print(
+                "[green]This is your token. Save it for later, you will not be able to get the value again:[/green]\n"
+            )
+            print(api_key["value"])
+            print(
+                "[green]\nNote: you can use the --activate flag to save a key in your local project settings when creating a key.[/green]\n"
+            )
+        else:
+            print("[green]This is your token:[/green]\n")
+            print(api_key["value"])
 
-    client = await get_client()
-    await client.delete_project_api_key(project_id=project_id, id=id)
     await client.close()
-
-
-@app.async_command("show")
-async def show(*, project_id: ProjectIdOption = None, api_key_id: str):
-    client = await get_client()
-    try:
-        project_id = await resolve_project_id(project_id=project_id)
-
-        key = await client.decrypt_project_api_key(project_id=project_id, id=api_key_id)
-
-        print(key["token"])
-
-    finally:
-        await client.close()
+    if activate:
+        await set_active_api_key(project_id=project_id, key=api_key["value"])
+        print(
+            "[green]your api key has been activated and will be used automatically with commands that require a key[/green]\n"
+        )
 
 
 @app.async_command("activate")
 async def activate(
-    api_key_id: str | None = typer.Argument(None),
+    *,
     project_id: ProjectIdOption = None,
-    interactive: bool = typer.Option(
-        False,
-        "-i",
-        "--interactive",
-        help="Interactively select or create an api key",
-    ),
+    key: str,
 ):
-    client = await get_client()
-    try:
-        project_id = await resolve_project_id(project_id)
-        if interactive:
-            response = await client.list_project_api_keys(project_id=project_id)
-            api_keys = response["keys"]
-
-            if not api_keys:
-                if typer.confirm(
-                    "There are no API keys. Would you like to create one?",
-                    default=True,
-                ):
-                    name = typer.prompt("API key name")
-                    created = await client.create_project_api_key(
-                        project_id=project_id,
-                        name=name,
-                        description="",
-                    )
-                    api_key_id = created["id"]
-                else:
-                    raise typer.Exit(code=0)
-            else:
-                for idx, key in enumerate(api_keys, start=1):
-                    print(f"[{idx}] {key['name']} ({key['id']})")
-                new_key_index = len(api_keys) + 1
-                print(f"[{new_key_index}] Create a new api key")
-                exit_index = new_key_index + 1
-                print(f"[{exit_index}] Exit")
-
-                choice = typer.prompt("Select an api key", type=int)
-                if choice == exit_index:
-                    return
-                elif choice == new_key_index:
-                    name = typer.prompt("API key name")
-                    created = await client.create_project_api_key(
-                        project_id=project_id,
-                        name=name,
-                        description="",
-                    )
-                    api_key_id = created["id"]
-                elif 1 <= choice <= len(api_keys):
-                    api_key_id = api_keys[choice - 1]["id"]
-                else:
-                    print("[red]Invalid selection[/red]")
-                    raise typer.Exit(code=1)
+    project_id = await resolve_project_id(project_id=project_id)
+    if activate:
+        await set_active_api_key(project_id=project_id, key=key)
 
-        if api_key_id is None and not interactive:
-            print("[red]api_key_id required[/red]")
-            raise typer.Exit(code=1)
 
-        response = await client.list_project_api_keys(project_id=project_id)
-        api_keys = response["keys"]
-        for api_key in api_keys:
-            if api_key["id"] == api_key_id:
-                await set_active_api_key(project_id=project_id, api_key_id=api_key_id)
-                return api_key_id
+@app.async_command("delete")
+async def delete(*, project_id: ProjectIdOption = None, id: str):
+    project_id = await resolve_project_id(project_id=project_id)
 
-        print(f"[red]Invalid api key id or project id: {project_id}[/red]")
-        raise typer.Exit(code=1)
-    finally:
-        await client.close()
+    client = await get_client()
+    await client.delete_api_key(project_id=project_id, id=id)
+    await client.close()