meshagent-cli 0.7.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

meshagent/cli/services.py

@@ -9,7 +9,7 @@ from aiohttp import ClientResponseError
 import pathlib
 from meshagent.cli import async_typer
 from meshagent.api.services import well_known_service_path
-from meshagent.api.specs.service import ServiceSpec
+from meshagent.api.specs.service import ServiceSpec, ServiceTemplateSpec
 from meshagent.api.keys import parse_api_key
 
 import asyncio
@@ -35,27 +35,53 @@ from meshagent.api import (
 )
 from meshagent.cli.common_options import OutputFormatOption
 
+from pydantic import RootModel
 from pydantic_yaml import parse_yaml_raw_as
 
 
 from meshagent.cli.call import _make_call
 
+
 app = async_typer.AsyncTyper(help="Manage services for your project")
 
 
+class ServiceTemplateValues(RootModel[dict[str, str]]):
+    pass
+
+
+def _load_template_values(
+    values_file: Optional[str],
+    values: Optional[list[str]] = None,
+) -> dict[str, str]:
+    template_values: dict[str, str] = {}
+
+    if values_file is not None:
+        with open(str(pathlib.Path(values_file).expanduser().resolve()), "rb") as f:
+            template_values = parse_yaml_raw_as(ServiceTemplateValues, f.read()).root
+
+    if values:
+        for item in values:
+            if "=" not in item:
+                raise typer.BadParameter("Template values must be key=value")
+            key, value = item.split("=", 1)
+            if not key:
+                raise typer.BadParameter("Template values must include a key")
+            template_values[key] = value
+
+    return template_values
+
+
 @app.async_command("create")
 async def service_create(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     file: Annotated[
         str,
         typer.Option("--file", "-f", help="File path to a service definition"),
     ],
     room: Annotated[
         Optional[str],
-        typer.Option(
-            "--room", "-r", help="The name of a room to create the service for"
-        ),
+        typer.Option("--room", help="The name of a room to create the service for"),
     ] = None,
 ):
     """Create a service attached to the project."""
@@ -94,7 +120,7 @@ async def service_create(
 @app.async_command("update")
 async def service_update(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     id: Optional[str] = None,
     file: Annotated[
         str,
@@ -108,9 +134,7 @@ async def service_update(
     ] = False,
     room: Annotated[
         Optional[str],
-        typer.Option(
-            "--room", "-r", help="The name of a room to update the service for"
-        ),
+        typer.Option("--room", help="The name of a room to update the service for"),
     ] = None,
 ):
     """Create a service attached to the project."""
@@ -176,10 +200,217 @@ async def service_update(
         await client.close()
 
 
+@app.async_command("validate")
+async def service_validate(
+    *,
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="File path to a service definition"),
+    ],
+):
+    """Validate a service spec from a YAML file."""
+    try:
+        with open(str(pathlib.Path(file).expanduser().resolve()), "rb") as f:
+            spec = parse_yaml_raw_as(ServiceSpec, f.read())
+    except Exception as exc:
+        print(f"[red]Invalid service spec: {exc}[/red]")
+        raise typer.Exit(code=1)
+
+    print(f"[green]Service spec is valid:[/] {spec.metadata.name}")
+
+
+@app.async_command("create-template")
+async def service_create_template(
+    *,
+    project_id: ProjectIdOption,
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="File path to a service template"),
+    ],
+    values: Annotated[
+        Optional[str],
+        typer.Option("--values-file", help="File path to template values"),
+    ] = None,
+    value: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--value",
+            "-v",
+            help="Template value override (key=value)",
+        ),
+    ] = None,
+    room: Annotated[
+        Optional[str],
+        typer.Option("--room", help="The name of a room to create the service for"),
+    ] = None,
+):
+    """Create a service from a ServiceTemplate spec."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        with open(str(pathlib.Path(file).expanduser().resolve()), "rb") as f:
+            template = f.read()
+
+        template_values = _load_template_values(values, value)
+
+        try:
+            if room is None:
+                service = await client.create_service_from_template(
+                    project_id=project_id, template=template, values=template_values
+                )
+            else:
+                service = await client.create_room_service_from_template(
+                    project_id=project_id,
+                    template=template,
+                    values=template_values,
+                    room_name=room,
+                )
+        except ClientResponseError as exc:
+            if exc.status == 409:
+                print(
+                    f"[red]Service name already in use: {template.metadata.name}[/red]"
+                )
+                raise typer.Exit(code=1)
+            raise
+        else:
+            service_id = service.id or ""
+            print(f"[green]Created service:[/] {service_id}")
+
+    finally:
+        await client.close()
+
+
+@app.async_command("update-template")
+async def service_update_template(
+    *,
+    project_id: ProjectIdOption,
+    id: Optional[str] = None,
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="File path to a service template"),
+    ],
+    values: Annotated[
+        Optional[str],
+        typer.Option("--values-file", help="File path to template values"),
+    ] = None,
+    value: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--value",
+            "-v",
+            help="Template value override (key=value)",
+        ),
+    ] = None,
+    create: Annotated[
+        Optional[bool],
+        typer.Option(
+            help="create the service if it does not exist",
+        ),
+    ] = False,
+    room: Annotated[
+        Optional[str],
+        typer.Option("--room", help="The name of a room to update the service for"),
+    ] = None,
+):
+    """Update a service using a ServiceTemplate spec."""
+    client = await get_client()
+    try:
+        project_id = await resolve_project_id(project_id)
+
+        with open(str(pathlib.Path(file).expanduser().resolve()), "rb") as f:
+            template = f.read()
+
+        template_values = _load_template_values(values, value)
+
+        try:
+            if id is None:
+                if room is None:
+                    services = await client.list_services(project_id=project_id)
+                else:
+                    services = await client.list_room_services(
+                        project_id=project_id, room_name=room
+                    )
+
+                for s in services:
+                    if s.metadata.name == template.metadata.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:
+                if room is None:
+                    service = await client.create_service_from_template(
+                        project_id=project_id,
+                        template=template,
+                        values=template_values,
+                    )
+                else:
+                    service = await client.create_room_service_from_template(
+                        project_id=project_id,
+                        template=template,
+                        values=template_values,
+                        room_name=room,
+                    )
+                id = service.id
+            else:
+                if room is None:
+                    service = await client.update_service_from_template(
+                        project_id=project_id,
+                        service_id=id,
+                        template=template,
+                        values=template_values,
+                    )
+                else:
+                    service = await client.update_room_service_from_template(
+                        project_id=project_id,
+                        service_id=id,
+                        template=template,
+                        values=template_values,
+                        room_name=room,
+                    )
+                if service.id is not None:
+                    id = service.id
+
+        except ClientResponseError as exc:
+            if exc.status == 409:
+                print(
+                    f"[red]Service name already in use: {template.metadata.name}[/red]"
+                )
+                raise typer.Exit(code=1)
+            raise
+        else:
+            print(f"[green]Updated service:[/] {id}")
+
+    finally:
+        await client.close()
+
+
+@app.async_command("validate-template")
+async def service_validate_template(
+    *,
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="File path to a service template"),
+    ],
+):
+    """Validate a service template from a YAML file."""
+    try:
+        with open(str(pathlib.Path(file).expanduser().resolve()), "rb") as f:
+            template = parse_yaml_raw_as(ServiceTemplateSpec, f.read())
+    except Exception as exc:
+        print(f"[red]Invalid service template: {exc}[/red]")
+        raise typer.Exit(code=1)
+
+    print(f"[green]Service template is valid:[/] {template.metadata.name}")
+
+
 @app.async_command("run")
 async def service_run(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     command: str,
     port: Annotated[
         int,
@@ -238,11 +469,26 @@ async def service_run(
             run_tasks = []
 
             async def run_service(port: int):
-                code, output = await _run_process(
-                    cmd=shlex.split("python3 " + command),
-                    log=True,
-                    env={**os.environ, "MESHAGENT_PORT": str(port)},
-                )
+                if command.endswith(".py"):
+                    code, output = await _run_process(
+                        cmd=shlex.split("python3 " + command),
+                        log=True,
+                        env={**os.environ, "MESHAGENT_PORT": str(port)},
+                    )
+
+                elif command.endswith(".dart"):
+                    code, output = await _run_process(
+                        cmd=shlex.split("dart run " + command),
+                        log=True,
+                        env={**os.environ, "MESHAGENT_PORT": str(port)},
+                    )
+
+                else:
+                    code, output = await _run_process(
+                        cmd=shlex.split(command),
+                        log=True,
+                        env={**os.environ, "MESHAGENT_PORT": str(port)},
+                    )
 
                 if code != 0:
                     print(f"[red]{output}[/red]")
@@ -274,11 +520,12 @@ async def service_run(
                             print("[red]unable to read service spec[/red]")
                             raise typer.Exit(-1)
 
+            print(f"getting spec {port}", flush=True)
             spec = await get_spec(port)
 
             sys.stdout.write("\n")
 
-            for p in spec.ports:
+            for p in spec.ports or []:
                 print(f"[bold green]Connecting port {p.num}...[/bold green]")
 
                 for endpoint in p.endpoints:
@@ -319,7 +566,7 @@ async def service_run(
 @app.async_command("show")
 async def service_show(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     service_id: Annotated[str, typer.Argument(help="ID of the service to show")],
 ):
     """Show a services for the project."""
@@ -337,13 +584,11 @@ async def service_show(
 @app.async_command("list")
 async def service_list(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     o: OutputFormatOption = "table",
     room: Annotated[
         Optional[str],
-        typer.Option(
-            "--room", "-r", help="The name of a room to list the services for"
-        ),
+        typer.Option("--room", help="The name of a room to list the services for"),
     ] = None,
 ):
     """List all services for the project."""
@@ -359,9 +604,7 @@ async def service_list(
         )
 
         if o == "json":
-            print(
-                {"services": [svc.model_dump(mode="json") for svc in services]}
-            ).model_dump_json(indent=2)
+            print({"services": [svc.model_dump(mode="json") for svc in services]})
         else:
             print_json_table(
                 [
@@ -385,25 +628,14 @@ async def service_list(
 @app.async_command("delete")
 async def service_delete(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     service_id: Annotated[str, typer.Argument(help="ID of the service to delete")],
-    room: Annotated[
-        Optional[str],
-        typer.Option(
-            "--room", "-r", help="The name of a room to delete the service for"
-        ),
-    ] = None,
 ):
     """Delete a service."""
     client = await get_client()
     try:
         project_id = await resolve_project_id(project_id)
-        if room is None:
-            await client.delete_service(project_id=project_id, service_id=service_id)
-        else:
-            await client.delete_service(
-                project_id=project_id, service_id=service_id, room_name=room
-            )
+        await client.delete_service(project_id=project_id, service_id=service_id)
         print(f"[green]Service {service_id} deleted.[/]")
     finally:
         await client.close()

meshagent/cli/sessions.py

@@ -2,11 +2,11 @@ from meshagent.cli import async_typer
 from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
 from meshagent.cli.common_options import ProjectIdOption
 
-app = async_typer.AsyncTyper()
+app = async_typer.AsyncTyper(help="Inspect recent sessions and events")
 
 
-@app.async_command("list")
-async def list(*, project_id: ProjectIdOption = None):
+@app.async_command("list", help="List recent sessions")
+async def list(*, project_id: ProjectIdOption):
     client = await get_client()
     sessions = await client.list_recent_sessions(
         project_id=await resolve_project_id(project_id=project_id)
@@ -15,8 +15,8 @@ async def list(*, project_id: ProjectIdOption = None):
     await client.close()
 
 
-@app.async_command("show")
-async def show(*, project_id: ProjectIdOption = None, session_id: str):
+@app.async_command("show", help="Show events for a session")
+async def show(*, project_id: ProjectIdOption, session_id: str):
     client = await get_client()
     events = await client.list_session_events(
         project_id=await resolve_project_id(project_id=project_id),

meshagent/cli/storage.py

@@ -55,7 +55,7 @@ def split_glob_subpath(subpath: str):
 @app.async_command("exists")
 async def storage_exists_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     path: str,
 ):
@@ -89,7 +89,7 @@ async def storage_exists_command(
 @app.async_command("cp")
 async def storage_cp_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     source_path: str,
     dest_path: str,
@@ -322,7 +322,7 @@ async def storage_cp_command(
 @app.async_command("show")
 async def storage_show_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     path: str,
     encoding: Annotated[
@@ -395,7 +395,7 @@ async def storage_show_command(
 @app.async_command("rm")
 async def storage_rm_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     path: str,
     recursive: Annotated[
@@ -599,7 +599,7 @@ async def storage_rm_command(
 @app.async_command("ls")
 async def storage_ls_command(
     *,
-    project_id: ProjectIdOption = None,
+    project_id: ProjectIdOption,
     room: RoomOption,
     path: Annotated[
         str, typer.Argument(..., help="Path to list (local or room://...)")