meshagent-cli 0.51.4__tar.gz → 0.51.6__tar.gz

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.51.4
+Version: 0.51.6
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -22,8 +22,8 @@ Requires-Dist: openpyxl~=3.1
 Requires-Dist: xlsxwriter~=3.2
 Requires-Dist: pathspec<2,>=1.0.3
 Requires-Dist: zstandard~=0.25.0
-Requires-Dist: meshagent-llm-proxy==0.51.4
-Requires-Dist: meshagent-codex==0.51.4
+Requires-Dist: meshagent-llm-proxy==0.51.6
+Requires-Dist: meshagent-codex==0.51.6
 Requires-Dist: rich~=14.3.0
 Requires-Dist: sounddevice~=0.5
 Requires-Dist: textual<9.0,>=8.2.3
@@ -32,23 +32,23 @@ Requires-Dist: prompt-toolkit~=3.0.52
 Requires-Dist: ascii-magic~=2.3
 Requires-Dist: pillow~=11.3.0
 Provides-Extra: all
-Requires-Dist: meshagent-agents[all]==0.51.4; extra == "all"
-Requires-Dist: meshagent-api[all]==0.51.4; extra == "all"
-Requires-Dist: meshagent-commoncrawl==0.51.4; extra == "all"
-Requires-Dist: meshagent-scrapy==0.51.4; extra == "all"
-Requires-Dist: meshagent-computers==0.51.4; extra == "all"
-Requires-Dist: meshagent-openai==0.51.4; extra == "all"
-Requires-Dist: meshagent-anthropic==0.51.4; extra == "all"
-Requires-Dist: meshagent-otel==0.51.4; extra == "all"
-Requires-Dist: meshagent-mcp==0.51.4; extra == "all"
-Requires-Dist: meshagent-tools==0.51.4; extra == "all"
+Requires-Dist: meshagent-agents[all]==0.51.6; extra == "all"
+Requires-Dist: meshagent-api[all]==0.51.6; extra == "all"
+Requires-Dist: meshagent-commoncrawl==0.51.6; extra == "all"
+Requires-Dist: meshagent-scrapy==0.51.6; extra == "all"
+Requires-Dist: meshagent-computers==0.51.6; extra == "all"
+Requires-Dist: meshagent-openai==0.51.6; extra == "all"
+Requires-Dist: meshagent-anthropic==0.51.6; extra == "all"
+Requires-Dist: meshagent-otel==0.51.6; extra == "all"
+Requires-Dist: meshagent-mcp==0.51.6; extra == "all"
+Requires-Dist: meshagent-tools==0.51.6; extra == "all"
 Requires-Dist: supabase-auth~=2.28.0; extra == "all"
 Requires-Dist: prompt-toolkit~=3.0.52; extra == "all"
 Provides-Extra: mcp-service
-Requires-Dist: meshagent-agents[all]==0.51.4; extra == "mcp-service"
-Requires-Dist: meshagent-api==0.51.4; extra == "mcp-service"
-Requires-Dist: meshagent-mcp==0.51.4; extra == "mcp-service"
-Requires-Dist: meshagent-tools==0.51.4; extra == "mcp-service"
+Requires-Dist: meshagent-agents[all]==0.51.6; extra == "mcp-service"
+Requires-Dist: meshagent-api==0.51.6; extra == "mcp-service"
+Requires-Dist: meshagent-mcp==0.51.6; extra == "mcp-service"
+Requires-Dist: meshagent-tools==0.51.6; extra == "mcp-service"
 Requires-Dist: supabase-auth~=2.28.0; extra == "mcp-service"
 Dynamic: license-file
 

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/meshagent/cli/containers.py

@@ -365,9 +365,15 @@ async def _drain_stream_plain(stream, *, show_progress: bool = True):
 
     t1 = asyncio.create_task(_logs())
     t2 = asyncio.create_task(_prog())
+    completed = False
     try:
-        return await stream
+        result = await stream
+        completed = True
+        return result
     finally:
+        if not completed:
+            t1.cancel()
+            t2.cancel()
         await asyncio.gather(t1, t2, return_exceptions=True)
 
 
@@ -511,8 +517,10 @@ async def _drain_stream_pretty(stream):
         t_logs = asyncio.create_task(_logs())
         t_prog = asyncio.create_task(_prog())
         t_ui = asyncio.create_task(_refresh())
+        completed = False
         try:
             result = await stream
+            completed = True
             return result
         finally:
             # Hide any still-visible tasks (e.g., indeterminate ones with total=None)
@@ -520,10 +528,11 @@ async def _drain_stream_pretty(stream):
                 progress.update(tid, visible=False)
             live.update(render())
 
-            for t in (t_logs, t_prog):
-                await t
-
+            if not completed:
+                t_logs.cancel()
+                t_prog.cancel()
             t_ui.cancel()
+            await asyncio.gather(t_logs, t_prog, t_ui, return_exceptions=True)
 
 
 async def _with_client(

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/meshagent/cli/containers_test.py

@@ -323,6 +323,38 @@ async def test_drain_stream_plain_strips_cri_log_prefixes(
     assert capsys.readouterr().out == "step 1\nstep 2\n"
 
 
+@pytest.mark.asyncio
+async def test_drain_stream_plain_cancels_consumers_when_stream_is_cancelled() -> None:
+    consumers_cancelled = 0
+
+    class _BlockingStream:
+        async def _consume(self):
+            nonlocal consumers_cancelled
+            try:
+                await asyncio.Future()
+                yield None
+            finally:
+                consumers_cancelled += 1
+
+        def logs(self):
+            return self._consume()
+
+        def progress(self):
+            return self._consume()
+
+        def __await__(self):
+            return asyncio.Future().__await__()
+
+    task = asyncio.create_task(containers._drain_stream_plain(_BlockingStream()))
+    await asyncio.sleep(0)
+    task.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await asyncio.wait_for(task, timeout=0.5)
+
+    assert consumers_cancelled == 2
+
+
 @pytest.mark.asyncio
 async def test_stream_build_job_logs_and_wait_for_exit_uses_build_log_stream(
     monkeypatch: pytest.MonkeyPatch,

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/meshagent/cli/image.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import hashlib
 import json
 import os
@@ -12,7 +13,7 @@ import tempfile
 from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass, field
 from pathlib import Path, PurePosixPath
-from typing import Annotated, Literal, Optional, Protocol, TYPE_CHECKING
+from typing import Annotated, Literal, Optional, Protocol, TYPE_CHECKING, TypeVar
 from urllib.parse import urlparse
 
 import typer
@@ -124,8 +125,8 @@ class _DeployDomainPromptHandler(Protocol):
 
 app = async_typer.AsyncTyper(help="Pack local directories as OCI images")
 _BUILD_CONTEXT_CHUNK_SIZE = 1024 * 1024
-_BUILD_WAIT_TIMEOUT_SECONDS = 600.0
 _CLIENT_CLOSE_TIMEOUT_SECONDS = 2.0
+_OPERATION_CANCEL_TIMEOUT_SECONDS = 1.0
 _DEFAULT_CONTEXT_MOUNT_PATH = "/context"
 _DEFAULT_REPOSITORY_TOKEN_TTL_SECONDS = 3600
 _DEPLOY_CACHE_CLEANUP_TIMEOUT_SECONDS = 30.0
@@ -151,6 +152,7 @@ _PROJECT_KEY_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
 _COOKIE_VALIDATION_METHOD = "cookie"
 DeployValidationMode = Literal["default", "cookie", "none"]
 ContainerTemplateOption = Literal["agent", "none"]
+_T = TypeVar("_T")
 _RESERVED_ROOM_SERVICE_PORTS_TEXT = ", ".join(
     str(port) for port in sorted(RESERVED_ROOM_SERVICE_PORTS)
 )
@@ -3758,6 +3760,7 @@ async def _wait_for_deployed_service_live(
     domain: str | None,
     liveness_path: str | None,
     queue_backed_route: bool = False,
+    expected_restart_count: int = 0,
     status_handler: Callable[[str], Awaitable[None]] | None = None,
     log_handler: Callable[[str], Awaitable[None]] | None = None,
 ) -> None:
@@ -3825,7 +3828,10 @@ async def _wait_for_deployed_service_live(
                 await asyncio.sleep(_DEPLOY_WAIT_POLL_INTERVAL_SECONDS)
                 continue
 
-            if state.restart_count > 0:
+            if (
+                state.restart_count > expected_restart_count
+                and state.last_exit_code not in (None, 0)
+            ):
                 if status_handler is None:
                     _print_service_exited_before_live(
                         service_name=service_name,
@@ -3860,23 +3866,17 @@ async def _wait_for_deployed_service_live(
                 and container_id is not None
                 and container_id != active_logs.container_id
             ):
-                if status_handler is None:
-                    _print_service_exited_before_live(
-                        service_name=service_name,
-                        service_id=service_id,
-                        exit_code=state.last_exit_code,
-                    )
-                else:
-                    exit_code_text = (
-                        str(state.last_exit_code)
-                        if state.last_exit_code is not None
-                        else "unknown"
-                    )
-                    await status_handler(
-                        "Service container changed before the service was live: "
-                        f"{service_name} ({service_id}), exit code {exit_code_text}"
-                    )
-                raise typer.Exit(code=1)
+                await _stop_deploy_log_stream(active_logs=active_logs)
+                await _emit_deploy_status(
+                    status_handler,
+                    rich_message=f"[cyan]Tailing container logs:[/] {container_id}",
+                    plain_message=f"Tailing container logs: {container_id}",
+                )
+                active_logs = _start_deploy_log_stream(
+                    client=client,
+                    container_id=container_id,
+                    log_handler=log_handler,
+                )
 
             if container_id is None or state.state != "running":
                 await asyncio.sleep(_DEPLOY_WAIT_POLL_INTERVAL_SECONDS)
@@ -3974,6 +3974,70 @@ async def _build_local_context_archive(
         raise
 
 
+def _consume_background_task_result(task: asyncio.Future[object]) -> None:
+    if task.cancelled():
+        return
+    with contextlib.suppress(Exception):
+        task.exception()
+
+
+async def _await_room_build_operation(
+    *,
+    client: RoomClient,
+    operation: Awaitable[_T],
+    operation_name: str,
+) -> _T:
+    loop = asyncio.get_running_loop()
+    disconnected = loop.create_future()
+
+    def on_disconnected(*, reason: str | None = None) -> None:
+        if not disconnected.done():
+            disconnected.set_result(reason)
+
+    observes_disconnects = isinstance(client, RoomClient)
+    if observes_disconnects:
+        client.on("disconnected", on_disconnected)
+    operation_task = asyncio.ensure_future(operation)
+    try:
+        done, _ = await asyncio.wait(
+            {operation_task, disconnected},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if operation_task in done:
+            return await operation_task
+        reason = disconnected.result()
+        detail = f": {reason}" if reason else ""
+        raise RuntimeError(
+            f"room connection lost while {operation_name}{detail}; "
+            "the in-flight operation cannot be resumed safely. Retry the deploy."
+        )
+    finally:
+        if observes_disconnects:
+            client.off("disconnected", on_disconnected)
+        if not disconnected.done():
+            disconnected.cancel()
+        if not operation_task.done():
+            operation_task.cancel()
+            done, _ = await asyncio.wait(
+                {operation_task}, timeout=_OPERATION_CANCEL_TIMEOUT_SECONDS
+            )
+            if operation_task not in done:
+                operation_task.add_done_callback(_consume_background_task_result)
+
+
+async def _close_room_client(client: RoomClient) -> None:
+    close_task = asyncio.create_task(client.__aexit__(None, None, None))
+    done, _ = await asyncio.wait({close_task}, timeout=_CLIENT_CLOSE_TIMEOUT_SECONDS)
+    if close_task in done:
+        await close_task
+        return
+    close_task.cancel()
+    close_task.add_done_callback(_consume_background_task_result)
+    sys.stderr.write(
+        "Room client did not close promptly after the build; abandoning cleanup.\n"
+    )
+
+
 async def _run_image_pack_stage(
     *,
     resolved_project_id: str | None,
@@ -4024,36 +4088,38 @@ async def _run_image_pack_stage(
                 )
             },
         )
-        build_id = await client.containers.build(
-            tags=[parsed_tag.value],
-            mount_path=_DEFAULT_CONTEXT_MOUNT_PATH,
-            context_path=_DEFAULT_CONTEXT_MOUNT_PATH,
-            dockerfile_path=_generated_pack_dockerfile_path(
-                mount_path=_DEFAULT_CONTEXT_MOUNT_PATH
+        build_id = await _await_room_build_operation(
+            client=client,
+            operation=client.containers.build(
+                tags=[parsed_tag.value],
+                mount_path=_DEFAULT_CONTEXT_MOUNT_PATH,
+                context_path=_DEFAULT_CONTEXT_MOUNT_PATH,
+                dockerfile_path=_generated_pack_dockerfile_path(
+                    mount_path=_DEFAULT_CONTEXT_MOUNT_PATH
+                ),
+                optimize_image=True,
+                private=False,
+                credentials=registry_credentials,
+                builder_name=_default_builder_name(client=client),
+                chunks=_iter_file_chunks(archive_path),
+                size=archive_size,
             ),
-            optimize_image=True,
-            private=False,
-            credentials=registry_credentials,
-            builder_name=_default_builder_name(client=client),
-            chunks=_iter_file_chunks(archive_path),
-            size=archive_size,
+            operation_name="uploading the build context",
+        )
+        exit_code = await _await_room_build_operation(
+            client=client,
+            operation=_stream_build_job_logs_and_wait_for_exit(
+                client=client,
+                build_id=build_id,
+            ),
+            operation_name="waiting for the image build and publish",
         )
-        try:
-            exit_code = await asyncio.wait_for(
-                _stream_build_job_logs_and_wait_for_exit(
-                    client=client,
-                    build_id=build_id,
-                ),
-                timeout=_BUILD_WAIT_TIMEOUT_SECONDS,
-            )
-        except TimeoutError as exc:
-            raise RuntimeError("timed out waiting for image build") from exc
         if exit_code != 0:
             raise typer.Exit(code=exit_code)
     finally:
         if context_archive_temp_dir is not None:
             context_archive_temp_dir.cleanup()
-        await client.__aexit__(None, None, None)
+        await _close_room_client(client)
         await account_client.close()
 
 
@@ -4134,46 +4200,53 @@ async def _run_image_build_stage(
             rich_message=f"[cyan]Uploading build context ({archive_size_text})...[/cyan]",
             plain_message=f"Uploading build context ({archive_size_text})...",
         )
-        build_id = await client.containers.build(
-            tags=tags,
-            mount_path=build_inputs.pack_spec.mount_path,
-            context_path=build_inputs.context_path,
-            dockerfile_path=build_inputs.dockerfile_path,
-            optimize_image=optimize,
-            private=private,
-            credentials=credentials,
-            builder_name=resolved_builder_name,
-            chunks=_iter_file_chunks_with_progress(
-                path=archive_path,
+        build_id = await _await_room_build_operation(
+            client=client,
+            operation=client.containers.build(
+                tags=tags,
+                mount_path=build_inputs.pack_spec.mount_path,
+                context_path=build_inputs.context_path,
+                dockerfile_path=build_inputs.dockerfile_path,
+                optimize_image=optimize,
+                private=private,
+                credentials=credentials,
+                builder_name=resolved_builder_name,
+                chunks=_iter_file_chunks_with_progress(
+                    path=archive_path,
+                    size=archive_size,
+                    status_handler=status_handler,
+                ),
                 size=archive_size,
-                status_handler=status_handler,
             ),
-            size=archive_size,
+            operation_name="uploading the build context",
         )
         await _emit_deploy_status(
             status_handler,
             rich_message="[cyan]Starting image build...[/cyan]",
             plain_message="Starting image build...",
         )
-        try:
-            if log_handler is None:
-                exit_code = await asyncio.wait_for(
+        if log_handler is None:
+            exit_code = await _await_room_build_operation(
+                client=client,
+                operation=(
                     _stream_build_job_logs_and_wait_for_exit(
                         client=client, build_id=build_id
-                    ),
-                    timeout=_BUILD_WAIT_TIMEOUT_SECONDS,
-                )
-            else:
-                exit_code = await asyncio.wait_for(
+                    )
+                ),
+                operation_name="waiting for the image build and publish",
+            )
+        else:
+            exit_code = await _await_room_build_operation(
+                client=client,
+                operation=(
                     _stream_build_job_logs_and_wait_for_exit_tui(
                         client=client,
                         build_id=build_id,
                         log_handler=log_handler,
-                    ),
-                    timeout=_BUILD_WAIT_TIMEOUT_SECONDS,
-                )
-        except TimeoutError as exc:
-            raise RuntimeError("timed out waiting for image build") from exc
+                    )
+                ),
+                operation_name="waiting for the image build and publish",
+            )
         if exit_code != 0:
             await _emit_deploy_status(
                 status_handler,
@@ -4181,10 +4254,14 @@ async def _run_image_build_stage(
                 plain_message=f"Image build failed: exit code {exit_code}",
             )
             raise typer.Exit(code=exit_code)
-        published_image = await _resolve_completed_build_image(
+        published_image = await _await_room_build_operation(
             client=client,
-            build_id=build_id,
-            parsed_tag=parsed_tag,
+            operation=_resolve_completed_build_image(
+                client=client,
+                build_id=build_id,
+                parsed_tag=parsed_tag,
+            ),
+            operation_name="resolving the published image",
         )
         await _emit_deploy_status(
             status_handler,
@@ -4200,7 +4277,7 @@ async def _run_image_build_stage(
     finally:
         if context_archive_temp_dir is not None:
             context_archive_temp_dir.cleanup()
-        await client.__aexit__(None, None, None)
+        await _close_room_client(client)
         await account_client.close()
 
 
@@ -5165,6 +5242,14 @@ async def deploy_image(
                     if previous_runtime_state is not None
                     else None
                 )
+                previous_restart_count = (
+                    previous_runtime_state.restart_count
+                    if previous_runtime_state is not None
+                    else 0
+                )
+                expected_restart_count = previous_restart_count + (
+                    0 if deploy_result.created else 1
+                )
                 liveness_path = (
                     _resolve_domain_liveness_path(
                         service_spec=deploy_plan.spec,
@@ -5191,6 +5276,7 @@ async def deploy_image(
                             domain=domain,
                             liveness_path=liveness_path,
                             queue_backed_route=queue_backed_route,
+                            expected_restart_count=expected_restart_count,
                             status_handler=status_handler,
                             log_handler=log_handler,
                         ),

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/meshagent/cli/image_test.py

@@ -83,6 +83,58 @@ def _fake_published_build_image(
     )
 
 
+@pytest.mark.asyncio
+async def test_room_build_operation_fails_immediately_on_disconnect(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class _FakeRoomClient:
+        def __init__(self) -> None:
+            self.handlers: dict[str, list[object]] = {}
+
+        def on(self, event_name: str, handler) -> None:
+            self.handlers.setdefault(event_name, []).append(handler)
+
+        def off(self, event_name: str, handler) -> None:
+            self.handlers[event_name].remove(handler)
+
+        def disconnect(self, reason: str) -> None:
+            for handler in list(self.handlers.get("disconnected", [])):
+                handler(reason=reason)
+
+    operation_cancelled = asyncio.Event()
+
+    async def operation() -> None:
+        try:
+            await asyncio.Future()
+        finally:
+            operation_cancelled.set()
+
+    client = _FakeRoomClient()
+    monkeypatch.setattr(image, "RoomClient", _FakeRoomClient)
+    task = asyncio.create_task(
+        image._await_room_build_operation(
+            client=client,
+            operation=operation(),
+            operation_name="waiting for the image build and publish",
+        )
+    )
+    await asyncio.sleep(0)
+    client.disconnect("websocket closed with code 1006")
+
+    with pytest.raises(
+        RuntimeError,
+        match=(
+            "room connection lost while waiting for the image build and publish: "
+            "websocket closed with code 1006; the in-flight operation cannot be "
+            "resumed safely"
+        ),
+    ):
+        await asyncio.wait_for(task, timeout=0.5)
+
+    assert operation_cancelled.is_set()
+    assert client.handlers["disconnected"] == []
+
+
 def _route_for_service(
     *, domain: str, room_name: str, port: str, service_id: str
 ) -> Route:
@@ -2133,6 +2185,13 @@ async def test_run_image_build_stage_requests_repository_token_and_prepends_regi
     class _FakeRoomClient:
         def __init__(self) -> None:
             self.containers = _FakeContainersClient()
+            self.handlers: dict[str, list[object]] = {}
+
+        def on(self, event_name: str, handler) -> None:
+            self.handlers.setdefault(event_name, []).append(handler)
+
+        def off(self, event_name: str, handler) -> None:
+            self.handlers[event_name].remove(handler)
 
         async def __aexit__(self, exc_type, exc, tb) -> None:
             del exc_type, exc, tb
@@ -2431,7 +2490,8 @@ async def test_wait_for_deployed_service_live_streams_logs_and_checks_service_li
         ServiceRuntimeState(
             service_id="service-1",
             state="running",
-            container_id="container-1",
+            container_id="container-2",
+            restart_count=3,
             status=ServiceRuntimeStatus(
                 ports=[
                     ServicePortRuntimeState(
@@ -2445,7 +2505,8 @@ async def test_wait_for_deployed_service_live_streams_logs_and_checks_service_li
         ServiceRuntimeState(
             service_id="service-1",
             state="running",
-            container_id="container-1",
+            container_id="container-2",
+            restart_count=3,
             status=ServiceRuntimeStatus(
                 ports=[
                     ServicePortRuntimeState(
@@ -2457,7 +2518,6 @@ async def test_wait_for_deployed_service_live_streams_logs_and_checks_service_li
             ),
         ),
     ]
-    fake_active_logs = SimpleNamespace(container_id="container-1")
 
     class _FakeServices:
         def __init__(self, runtime_states: list[ServiceRuntimeState]) -> None:
@@ -2479,7 +2539,7 @@ async def test_wait_for_deployed_service_live_streams_logs_and_checks_service_li
     def _fake_start_deploy_log_stream(*, client, container_id: str, log_handler=None):
         del client, log_handler
         captured["started_logs"].append(container_id)
-        return fake_active_logs
+        return SimpleNamespace(container_id=container_id)
 
     async def _fake_stop_deploy_log_stream(*, active_logs) -> None:
         captured["stopped_logs"].append(active_logs)
@@ -2508,8 +2568,11 @@ async def test_wait_for_deployed_service_live_streams_logs_and_checks_service_li
         liveness_path="/ready",
     )
 
-    assert captured["started_logs"] == ["container-1"]
-    assert captured["stopped_logs"] == [fake_active_logs]
+    assert captured["started_logs"] == ["container-1", "container-2"]
+    assert [active.container_id for active in captured["stopped_logs"]] == [
+        "container-1",
+        "container-2",
+    ]
     assert any("Service liveness is ready" in message for message in captured["prints"])
 
 

{meshagent_cli-0.51.4 → meshagent_cli-0.51.6}/meshagent/cli/routes.py

@@ -460,6 +460,11 @@ async def route_update(
                             if current_content is not None
                             else ""
                         ),
+                        notFound=(
+                            current_content.notFound
+                            if current_content is not None
+                            else None
+                        ),
                         cors=(
                             parsed_cors
                             if parsed_cors is not None
@@ -512,6 +517,13 @@ async def route_update(
                         current_path.pathType if current_path is not None else "prefix"
                     ),
                     "stripPrefix": strip_prefix,
+                    **(
+                        {"unavailable": current_path.unavailable}
+                        if current_path is not None
+                        and target.get("targetPort") is not None
+                        and current_path.unavailable is not None
+                        else {}
+                    ),
                     **target,
                 },
                 *[item.model_dump(mode="python") for item in route.spec.paths[1:]],

meshagent_cli-0.51.6/meshagent/cli/version.py

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