meshagent-api 0.41.9__tar.gz → 0.42.2__tar.gz

{meshagent_api-0.41.9/meshagent_api.egg-info → meshagent_api-0.42.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.41.9
+Version: 0.42.2
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com

{meshagent_api-0.41.9 → meshagent_api-0.42.2}/meshagent/api/client.py

@@ -1333,6 +1333,17 @@ class Meshagent:
             await self._raise_for_status(resp)
             return await resp.json()
 
+    async def get_project_by_key(self, project_key: str) -> Dict[str, Any]:
+        """
+        Corresponds to: GET /accounts/projects/by-key/{project_key}
+        Returns a JSON dict with { "id", "owner_user_id", "name", "project_key" }.
+        """
+        url = f"{self.base_url}/accounts/projects/by-key/{quote(project_key, safe='')}"
+
+        async with self._session.get(url, headers=self._get_headers()) as resp:
+            await self._raise_for_status(resp)
+            return await resp.json()
+
     async def get_project_info(self, project_id: str) -> ProjectInfo:
         url = f"{self.base_url}/accounts/projects/{project_id}"
 

{meshagent_api-0.41.9 → meshagent_api-0.42.2}/meshagent/api/client_test.py

@@ -12,6 +12,11 @@ from meshagent.api.managed_agents import (
 from meshagent.api.participant_token import ApiScope
 from meshagent.api.client import ManagedAgentGrant, Meshagent
 from meshagent.api.specs.service import (
+    RouteBackendSpec,
+    RouteMetadata,
+    RoutePathSpec,
+    RouteRoomBackendSpec,
+    RouteSpec,
     ScheduledTaskQueueSpec,
     ScheduledTaskSpec,
     ServiceMetadata,
@@ -98,6 +103,72 @@ async def test_render_template_accepts_decoded_json_response():
     ]
 
 
+@pytest.mark.asyncio
+async def test_create_route_omits_default_strip_prefix_from_paths():
+    session = _FakeSession([_FakeResponse(status=200, payload={})])
+    client = Meshagent(base_url="http://example.test", token="token", session=session)
+
+    await client.create_route(
+        project_id="project-1",
+        spec=RouteSpec(
+            metadata=RouteMetadata(name="app.example.test"),
+            domain="app.example.test",
+            backend=RouteBackendSpec(room=RouteRoomBackendSpec(name="room-1")),
+            paths=[RoutePathSpec(path="/", targetPort=3000)],
+        ),
+    )
+
+    assert session.calls == [
+        (
+            "post",
+            "http://example.test/accounts/projects/project-1/routes",
+            {
+                "spec": {
+                    "version": "v1",
+                    "kind": "Route",
+                    "metadata": {"name": "app.example.test", "annotations": {}},
+                    "domain": "app.example.test",
+                    "backend": {"room": {"name": "room-1"}, "agent": None},
+                    "paths": [
+                        {
+                            "path": "/",
+                            "pathType": "prefix",
+                            "targetPort": 3000,
+                        }
+                    ],
+                }
+            },
+        )
+    ]
+
+
+@pytest.mark.asyncio
+async def test_create_route_serializes_true_strip_prefix():
+    session = _FakeSession([_FakeResponse(status=200, payload={})])
+    client = Meshagent(base_url="http://example.test", token="token", session=session)
+
+    await client.create_route(
+        project_id="project-1",
+        spec=RouteSpec(
+            metadata=RouteMetadata(name="app.example.test"),
+            domain="app.example.test",
+            backend=RouteBackendSpec(room=RouteRoomBackendSpec(name="room-1")),
+            paths=[
+                RoutePathSpec(path="/api", targetPort=3000, stripPrefix=True),
+            ],
+        ),
+    )
+
+    assert session.calls[0][2]["spec"]["paths"] == [
+        {
+            "path": "/api",
+            "pathType": "prefix",
+            "stripPrefix": True,
+            "targetPort": 3000,
+        }
+    ]
+
+
 @pytest.mark.asyncio
 async def test_exchange_oauth_token_posts_form_encoded_token_request():
     session = _FakeSession(

{meshagent_api-0.41.9 → meshagent_api-0.42.2}/meshagent/api/room_server_client.py

@@ -1123,6 +1123,14 @@ class RoomClient:
         with contextlib.suppress(Exception):
             await protocol.__aexit__(None, None, None)
 
+    async def _close_protocol_shielded(self, protocol: Protocol) -> None:
+        close_task = asyncio.create_task(self._close_protocol(protocol))
+        try:
+            await asyncio.shield(close_task)
+        except asyncio.CancelledError:
+            await asyncio.shield(close_task)
+            raise
+
     def _replace_protocol(self, next_protocol: Protocol) -> None:
         current_protocol = self._protocol_instance
         self.protocol._unbind(current_protocol)
@@ -1644,13 +1652,19 @@ class RoomClient:
         self._close_watcher_task = None
         if close_watcher is not None:
             close_watcher.cancel()
+        close_cancelled = False
         try:
-            await self._close_protocol(self._protocol_instance)
+            try:
+                await self._close_protocol_shielded(self._protocol_instance)
+            except asyncio.CancelledError:
+                close_cancelled = True
             lifecycle_task = self._lifecycle_task
             if lifecycle_task is not None:
                 await asyncio.gather(lifecycle_task, return_exceptions=True)
             await self.sync.stop()
             await self.messaging.stop()
+            if close_cancelled:
+                raise asyncio.CancelledError
         finally:
             self._lifecycle_task = None
             self._entered = False
@@ -7639,11 +7653,35 @@ class ImportedImage(BaseModel):
     refs: List[str] = Field(default_factory=list)
 
 
+class PublishedImageLayer(BaseModel):
+    digest: str
+    size_bytes: int
+    media_type: Optional[str] = None
+
+
+class PublishedImageStats(BaseModel):
+    manifest_media_type: str
+    layer_count: int
+    total_layer_size_bytes: int
+    total_size_bytes: int
+    layers: List[PublishedImageLayer] = Field(default_factory=list)
+    config_size_bytes: Optional[int] = None
+
+
+class PublishedBuildImage(BaseModel):
+    tag: str
+    digest: str
+    resolved_ref: str
+    optimized: bool
+    stats: Optional[PublishedImageStats] = None
+
+
 class BuildJob(BaseModel):
     id: str
     tag: str
     status: Literal["queued", "running", "failed", "cancelled", "succeeded"]
     exit_code: Optional[int] = None
+    published_images: List[PublishedBuildImage] = Field(default_factory=list)
 
 
 class ContainerStartedBy(BaseModel):
@@ -7651,16 +7689,38 @@ class ContainerStartedBy(BaseModel):
     name: str
 
 
+class RoomContainerPort(BaseModel):
+    container_port: int
+    host_port: int
+
+
+class RoomContainerStats(BaseModel):
+    cpu_usage_nano_cores: Optional[int] = None
+    memory_usage_bytes: Optional[int] = None
+    memory_working_set_bytes: Optional[int] = None
+    timestamp_ns: Optional[int] = None
+
+
+class ContainerExitStatus(BaseModel):
+    exit_code: int
+    reason: Optional[str] = None
+    message: Optional[str] = None
+    oom_killed: Optional[bool] = None
+
+
 class RoomContainer(BaseModel):
     id: str
     image: Optional[str] = None
+    image_id: Optional[str] = None
     status: Optional[str] = None
     name: Optional[str] = None
-    ports: list[int] = Field(default_factory=list)
+    ports: list[RoomContainerPort] = Field(default_factory=list)
     started_by: ContainerStartedBy
     state: Literal["CREATED", "RUNNING", "EXITED", "UNKNOWN"]
     private: bool
     service_id: Optional[str] = None
+    stats: Optional[RoomContainerStats] = None
+    exit_status: Optional[ContainerExitStatus] = None
 
     # Accept arbitrary extras (names, created, state, etc.)
     model_config = ConfigDict(extra="allow")
@@ -8601,6 +8661,10 @@ class ContainersClient:
         )
 
     async def wait_for_exit(self, *, container_id: str) -> int:
+        status = await self.wait_for_exit_status(container_id=container_id)
+        return status.exit_code
+
+    async def wait_for_exit_status(self, *, container_id: str) -> ContainerExitStatus:
         response = await self.room.invoke(
             toolkit="containers",
             tool="wait_for_exit",
@@ -8611,7 +8675,7 @@ class ContainersClient:
         exit_code = response.json.get("exit_code")
         if isinstance(exit_code, bool) or not isinstance(exit_code, int):
             raise self._unexpected_response_error(operation="wait_for_exit")
-        return exit_code
+        return ContainerExitStatus.model_validate(response.json)
 
     async def delete(self, *, container_id: str) -> None:
         await self.room.invoke(

{meshagent_api-0.41.9 → meshagent_api-0.42.2}/meshagent/api/room_server_client_test.py

@@ -220,6 +220,18 @@ class _CloseableProtocol(_FakeProtocol):
         return self._close_reason
 
 
+class _SlowExitProtocol(_FakeProtocol):
+    def __init__(self) -> None:
+        super().__init__()
+        self.exit_started = asyncio.Event()
+        self.allow_exit = asyncio.Event()
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        self.exit_started.set()
+        await self.allow_exit.wait()
+        await super().__aexit__(exc_type, exc, tb)
+
+
 def test_room_exception_defaults_to_invalid_request_code() -> None:
     ex = RoomException("boom")
     assert ex.code == ErrorCode.INVALID_REQUEST
@@ -2051,6 +2063,26 @@ async def test_room_client_exit_fails_pending_requests_and_cancels_close_watcher
     assert client._close_watcher_task is None
 
 
+@pytest.mark.asyncio
+async def test_room_client_exit_shields_protocol_close_from_cancellation() -> None:
+    protocol = _SlowExitProtocol()
+    client = RoomClient(protocol_factory=protocol.create_factory())
+
+    exit_task = asyncio.create_task(client.__aexit__(None, None, None))
+    await asyncio.wait_for(protocol.exit_started.wait(), timeout=1)
+
+    exit_task.cancel()
+    await asyncio.sleep(0)
+    assert not exit_task.done()
+
+    protocol.allow_exit.set()
+    with pytest.raises(asyncio.CancelledError):
+        await asyncio.wait_for(exit_task, timeout=1)
+
+    assert protocol.exited is True
+    assert client._close_watcher_task is None
+
+
 @pytest.mark.asyncio
 async def test_room_client_wait_for_close_ignores_unexpected_disconnects() -> None:
     controller = _ReconnectRoomController(schema=_simple_thread_schema())
@@ -4049,6 +4081,32 @@ async def test_containers_client_uses_room_invoke_with_strict_payloads() -> None
                                 "tag": "example:latest",
                                 "status": "running",
                                 "exit_code": None,
+                                "published_images": [
+                                    {
+                                        "tag": "example:latest",
+                                        "digest": "sha256:digest",
+                                        "resolved_ref": "example@sha256:digest",
+                                        "optimized": True,
+                                        "stats": {
+                                            "manifest_media_type": (
+                                                "application/vnd.oci.image.manifest.v1+json"
+                                            ),
+                                            "layer_count": 1,
+                                            "total_layer_size_bytes": 200,
+                                            "total_size_bytes": 300,
+                                            "config_size_bytes": 100,
+                                            "layers": [
+                                                {
+                                                    "digest": "sha256:layer",
+                                                    "size_bytes": 200,
+                                                    "media_type": (
+                                                        "application/vnd.oci.image.layer.v1.tar"
+                                                    ),
+                                                }
+                                            ],
+                                        },
+                                    }
+                                ],
                             }
                         ]
                     }
@@ -4070,6 +4128,7 @@ async def test_containers_client_uses_room_invoke_with_strict_payloads() -> None
             configs=[ConfigMountSpec()],
             empty_dirs=[EmptyDirMountSpec(path="/cache")],
         ),
+        template="agent",
     )
     await client.build(
         tags=["example:latest"],
@@ -4086,7 +4145,7 @@ async def test_containers_client_uses_room_invoke_with_strict_payloads() -> None
     await client.run_service(service_id="svc-1", env={"A": "1"})
     images = await client.list_images()
     inspection = await client.inspect_image(image_id="img-1")
-    await client.list_builds()
+    builds = await client.list_builds()
     await client.cancel_build(build_id="build-1")
     await client.delete_build(build_id="build-1")
     await client.list()
@@ -4119,6 +4178,10 @@ async def test_containers_client_uses_room_invoke_with_strict_payloads() -> None
     assert inspection.image.references == ["demo:latest"]
     assert inspection.target.digest == "sha256:target"
     assert inspection.content_size == 235
+    assert builds[0].published_images[0].resolved_ref == "example@sha256:digest"
+    assert builds[0].published_images[0].stats is not None
+    assert builds[0].published_images[0].stats.layer_count == 1
+    assert builds[0].published_images[0].stats.total_size_bytes == 300
 
     pull_input = room.requests[0]["input"]
     assert isinstance(pull_input, dict)
@@ -4130,6 +4193,7 @@ async def test_containers_client_uses_room_invoke_with_strict_payloads() -> None
     assert isinstance(run_input, dict)
     assert run_input["env"] == [{"key": "KEY", "value": "VALUE"}]
     assert run_input["ports"] == [{"container_port": 8080, "host_port": 80}]
+    assert run_input["template"] == "agent"
     assert isinstance(run_input["mounts"], dict)
     assert run_input["mounts"]["configs"] == [{"path": "/var/run/meshagent"}]
     assert run_input["mounts"]["empty_dirs"] == [{"path": "/cache", "read_only": False}]

{meshagent_api-0.41.9 → meshagent_api-0.42.2}/meshagent/api/specs/service.py

@@ -4,6 +4,7 @@ from pydantic import (
     ConfigDict,
     Field,
     field_validator,
+    model_serializer,
     model_validator,
 )
 from typing import Any, Optional, Literal
@@ -461,8 +462,16 @@ class RoutePathSpec(BaseModel):
 
     path: str = "/"
     pathType: Literal["prefix", "exact"] = "prefix"
+    stripPrefix: bool = False
     targetPort: str | int
 
+    @model_serializer(mode="wrap")
+    def serialize_route_path(self, handler: Any) -> dict[str, Any]:
+        data: dict[str, Any] = handler(self)
+        if not self.stripPrefix:
+            data.pop("stripPrefix", None)
+        return data
+
     @field_validator("path")
     @classmethod
     def validate_path(cls, value: str) -> str:
@@ -633,6 +642,13 @@ class EndpointSpec(BaseModel):
 class PortSpec(BaseModel):
     model_config = ConfigDict(extra="forbid")
     num: Literal["*"] | PositiveInt = "*"
+    host_port: Optional[PositiveInt] = Field(
+        None,
+        description=(
+            "optional room host port to publish this container port on; when set, "
+            "published defaults to true unless explicitly set"
+        ),
+    )
     type: Optional[Literal["http", "tcp"]] = "http"
     endpoints: list[EndpointSpec] = Field(
         default_factory=list, description="a list of endpoints exposed under this port"

meshagent_api-0.42.2/meshagent/api/version.py

@@ -0,0 +1 @@
+__version__ = "0.42.2"

{meshagent_api-0.41.9 → meshagent_api-0.42.2/meshagent_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.41.9
+Version: 0.42.2
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com

meshagent_api-0.41.9/meshagent/api/version.py

@@ -1 +0,0 @@
-__version__ = "0.41.9"