manta-node 0.6b0.dev526__py3-none-any.whl → 0.6b0.dev534__py3-none-any.whl

manta_node/cli/commands/start.py

@@ -17,7 +17,7 @@ from manta_common.logging_config import configure_logging
 from rich.console import Console
 
 from ...infrastructure.config import NodeConfigManager
-from ...node_orchestrator import Node
+from ...node_orchestrator import Node, NodeFatalError
 
 console = Console()
 
@@ -125,7 +125,15 @@ def start_node_foreground(
             stop_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await stop_task
-            start_task.result()  # Re-raise a genuine start failure unchanged
+            try:
+                start_task.result()  # Re-raise a genuine start failure unchanged
+            except NodeFatalError:
+                # Tear down a partially-started node before surfacing the fatal error.
+                try:
+                    await node.stop()
+                except Exception as exc:
+                    console.print(f"[red]Error during node cleanup: {exc}[/red]")
+                raise
             return False
 
         # MUST precede start_task.cancel(): Node.stop() skips the DISCONNECTED
@@ -136,7 +144,7 @@ def start_node_foreground(
             console.print(f"[red]Error during node cleanup: {exc}[/red]")
 
         start_task.cancel()
-        with contextlib.suppress(asyncio.CancelledError):
+        with contextlib.suppress(asyncio.CancelledError, NodeFatalError):
             await start_task
         return True
 

manta_node/infrastructure/filesystem/dataset_manager.py

@@ -5,12 +5,14 @@ from pathlib import Path
 from typing import Any
 
 from manta_common.build.common.informations import DatasetOverviews, Overview
-from manta_common.const import CHUNK_SIZE
 from manta_common.errors import MantaSecurityError, MantaValidationError
 from manta_common.traces import Tracer
 
 __all__ = ["DatasetManager"]
 
+# Bounded read size for streaming dataset files; not the 4 GiB message-size ceiling manta_common.CHUNK_SIZE.
+STREAM_CHUNK_SIZE = 1024 * 1024
+
 # File type to dtype mapping
 DTYPES = {
     ".txt": "text",
@@ -243,7 +245,7 @@ class DatasetManager:
         if not file_path.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
         with file_path.open("rb") as f:
-            while chunk := f.read(CHUNK_SIZE):
+            while chunk := f.read(STREAM_CHUNK_SIZE):
                 yield chunk
 
     def _validate_file_path(self, file_path: str) -> str:

manta_node/infrastructure/grpc/client.py

@@ -24,7 +24,7 @@ from manta_common.build.common.results import (
     ResultQuery,
 )
 from manta_common.build.common.system import Empty, Logs, Ok
-from manta_common.build.common.tasks import TaskScheduling
+from manta_common.build.common.tasks import TaskScheduling, TaskUpdate
 from manta_common.build.common.wireguard import (
     DeregisterWireGuardNodeRequest,
     RegisterWireGuardNodeRequest,
@@ -360,6 +360,26 @@ class NodeClient(GrpcClientBase):
         """
         return await self.call_service_method("schedule_task", request)
 
+    async def update_task(self, request: TaskUpdate) -> Ok:
+        """
+        Report a task status update to the manager.
+
+        This is the authoritative channel the manager's task scheduler
+        consumes; MQTT ``manager/update_task_status`` is a secondary,
+        lossy channel (refs #287).
+
+        Parameters
+        ----------
+        request : TaskUpdate
+            Task status update
+
+        Returns
+        -------
+        Ok
+            Response
+        """
+        return await self.call_service_method("update_task", request)
+
     async def send_error(self, manta_error: MantaError):
         """
         Send the error to the Manager

manta_node/infrastructure/mqtt/command_handler.py

@@ -1,5 +1,8 @@
 import asyncio
+import base64
 import io
+import json
+import re
 from collections.abc import AsyncIterable, Awaitable, Callable
 from datetime import datetime, timezone
 from logging import getLogger
@@ -12,7 +15,7 @@ from manta_common.build.common.mqtt import MqMetricsSnapshot, MqTaskUpdate
 from manta_common.build.common.system import Logs
 from manta_common.build.common.tasks import MqttTask, TaskStatus, TaskUpdate
 from manta_common.const import CHUNK_SIZE
-from manta_common.conversions import ID
+from manta_common.conversions import ID, b2x
 from manta_common.errors import (
     MantaError,
     MantaGRPCError,
@@ -42,6 +45,30 @@ def _is_permanent_upload_rejection(exc: Exception) -> bool:
     )
 
 
+_NODE_ID_CLAIM_PATTERN = re.compile(r"^[0-9a-fA-F]{24}$")
+
+
+def _node_id_from_token(secured_token: str) -> str | None:
+    """Return the 24-hex ``node_id`` claim from a JWT payload, else None.
+
+    Reads the payload without verifying the signature: the node trusts the
+    manager-minted token it already holds. Never logs the token.
+    """
+    try:
+        _, payload, _ = secured_token.split(".", 2)
+    except ValueError:
+        return None
+    try:
+        padded = payload + "=" * (-len(payload) % 4)
+        claims = json.loads(base64.urlsafe_b64decode(padded))
+    except (ValueError, UnicodeDecodeError):
+        return None
+    node_id = claims.get("node_id") if isinstance(claims, dict) else None
+    if not isinstance(node_id, str) or not _NODE_ID_CLAIM_PATTERN.fullmatch(node_id):
+        return None
+    return node_id
+
+
 class CommandHandler(Collector, MqttBase):
     """
     CommandHandler class to handle commands from the Manager.
@@ -97,12 +124,17 @@ class CommandHandler(Collector, MqttBase):
         self.max_concurrent_tasks = max_concurrent_tasks
         self.task_timeout = task_timeout
 
+        # Never expose the cluster JWT as the client id: derive it from the node_id claim.
+        client_id = ID(
+            _node_id_from_token(node_client.secured_token)
+            or b2x(node_client.secured_token.encode())
+        )
         MqttBase.__init__(
             self,
             mqtt_broker_host=mqtt_broker_host,
             mqtt_broker_port=mqtt_broker_port,
             topics=topics,
-            client_id=ID(node_client.metadata.get("authorization", "node_client")),
+            client_id=client_id,
             ssl_cert_folder=ssl_cert_folder,
         )
 
@@ -171,6 +203,9 @@ class CommandHandler(Collector, MqttBase):
     async def get_task_logs(self, task_progression):
         return await self._task_manager.get_task_logs(task_progression)
 
+    async def get_image_task_status(self, swarm_id, task_id):
+        return await self._task_manager.get_image_task_status(swarm_id, task_id)
+
     async def restart_container(self, swarm_id, task_id):
         return await self._task_manager.restart_container(swarm_id, task_id)
 
@@ -539,6 +574,14 @@ class CommandHandler(Collector, MqttBase):
             "manager/update_task_status",
             MqTaskUpdate(token=self.node_client.secured_token, update=task_update),
         )
+        # Also report via the gRPC UpdateTask RPC the manager's scheduler consumes.
+        try:
+            await self.node_client.update_task(task_update)
+        except Exception:
+            self.tracer.exception(
+                f"Failed to report task status via gRPC for task "
+                f"{ID(task_update.task_id)}"
+            )
 
     async def send_task_logs(self, date: datetime, processed_logs: bytes):
         """

manta_node/node_orchestrator.py

@@ -2,7 +2,6 @@ import asyncio
 import socket
 import ssl
 import struct
-import sys
 import uuid
 from logging import getLogger
 from pathlib import Path
@@ -36,7 +35,16 @@ from .infrastructure.mqtt.command_handler import CommandHandler
 from .infrastructure.process.executor import ProcessExecutor
 from .task_manager import TaskManager
 
-__all__ = ["Node"]
+__all__ = ["Node", "NodeFatalError"]
+
+
+class NodeFatalError(Exception):
+    """Raised by Node.start()'s fatal paths instead of sys.exit() from inside a task.
+
+    The CLI maps it to a non-zero exit code and keeps shutdown ordering under
+    its own control.
+    """
+
 
 # Docker-specific exceptions. Imported lazily so a light node (no Docker
 # package installed) can import this module and run in process mode without
@@ -184,6 +192,8 @@ class Node:
     """
 
     __slots__ = [
+        "_stop_done",
+        "_stop_lock",
         "cert_folder",
         "command_handler",
         "command_loop",
@@ -262,6 +272,10 @@ class Node:
         self.command_loop = None
         self.light_server_task = None
 
+        # Serialise teardown so concurrent stop() callers wait and then no-op.
+        self._stop_lock = asyncio.Lock()
+        self._stop_done = False
+
         # Register configuration observer for runtime updates
         self.config_manager.register_observer(self._on_config_change)
 
@@ -365,11 +379,11 @@ class Node:
         Then, it will check if the manager is available by calling
         the `is_available` function of the node client.
         If the manager is not available, it will log an error and
-        exit with a non-zero status code.
+        raise a :code:`NodeFatalError` with a non-zero status report.
 
         Raises
         ------
-        SystemExit
+        NodeFatalError
             If the manager is not available.
         """
         # Log endpoint details before attempting connection
@@ -400,11 +414,13 @@ class Node:
                 f"  3. Verify JWT_SECRET matches between node and manager\n"
                 f"  4. Check network connectivity to {self.config.network.manager_host}:{self.config.network.manager_port}\n"
             )
-            sys.exit(troubleshooting)
+            raise NodeFatalError(troubleshooting) from error
         except MantaError as manta_error:
             tls_error = _find_tls_error(manta_error)
             if tls_error is not None:
-                sys.exit(self._tls_troubleshooting(manta_error, tls_error))
+                raise NodeFatalError(
+                    self._tls_troubleshooting(manta_error, tls_error)
+                ) from manta_error
 
             message = f"Manager authentication failed at {endpoint}: {manta_error}"
             self.tracer.exception(message)
@@ -418,11 +434,11 @@ class Node:
                 f"  - Verify secured_token in node config matches manager's JWT_SECRET\n"
                 f"  - Check token format: should be a valid JWT with 3 parts (header.payload.signature)\n"
             )
-            sys.exit(troubleshooting)
+            raise NodeFatalError(troubleshooting) from manta_error
         except Exception as exc:
             message = f"Unknown error connecting to {endpoint}: {exc}"
             self.tracer.exception(message)
-            sys.exit(f"[ERROR] {message}")
+            raise NodeFatalError(f"[ERROR] {message}") from exc
 
     async def start(self) -> None:
         """
@@ -436,7 +452,7 @@ class Node:
 
         Raises
         ------
-        SystemExit
+        NodeFatalError
             If MQTT client unreacheable or gRPC error occurs
         """
         await self.check_manager_availability()
@@ -542,14 +558,16 @@ class Node:
             await asyncio.gather(self.command_loop, self.light_server_task)
         except ConnectionRefusedError:
             self.tracer.exception("Unable to start and connect to MQTT Message Broker")
-            sys.exit("[ERROR] Unable to start and connect to MQTT Message Broker")
+            raise NodeFatalError(
+                "[ERROR] Unable to start and connect to MQTT Message Broker"
+            ) from None
         except GRPCError:
             self.tracer.exception("Unable to register to the Manager")
-            sys.exit("[ERROR] Unable to register to the Manager")
+            raise NodeFatalError("[ERROR] Unable to register to the Manager") from None
         except OSError as os_error:
             self.tracer.exception(f"OS error: {os_error}")
             await self.stop()
-            sys.exit(f"[ERROR] OS error: {os_error}")
+            raise NodeFatalError(f"[ERROR] OS error: {os_error}") from os_error
         except Exception as exc:
             # Docker-specific failures are only meaningful in container mode.
             # In process mode they would mask unrelated OS errors, so they are
@@ -561,39 +579,41 @@ class Node:
             ):
                 self.tracer.exception(f"Docker is not available: {exc}")
                 await self.stop()
-                sys.exit(f"[ERROR] Docker is not available: {exc}")
+                raise NodeFatalError(f"[ERROR] Docker is not available: {exc}") from exc
             self.tracer.exception(f"Unknown error: {exc}")
             await self.stop()
-            sys.exit(f"[ERROR] Unknown error: {exc}")
+            raise NodeFatalError(f"[ERROR] Unknown error: {exc}") from exc
 
     async def stop(self) -> None:
-        """
-        Stop the node
-        """
-        self.tracer.info("Stopping node")
-        if (
-            self.command_handler is not None
-            and self.command_loop is not None
-            and not self.command_loop.cancelled()
-        ):
-            self.tracer.info("Publishing node status to manager")
-            await self.command_handler.client.publish(
-                "manager/set_node_status",
-                NodeStatus(status=NodeStatusEnum.DISCONNECTED).SerializeToString(),
-            )
-
-        if self.command_handler is not None:
-            self.tracer.info("Cleaning up command handler")
-            await self.command_handler.clean()
-
-        if self.command_loop is not None:
-            self.tracer.info("Stopping command loop")
-            self.command_loop.cancel()
-
-        if self.light_server_task is not None:
-            self.tracer.info("Stopping light server task")
-            self.light_server_task.cancel()
-
-        # if self.server is not None:
-        #     self.tracer.info("Stopping light server")
-        #     self.server.close()
+        """Stop the node"""
+        async with self._stop_lock:
+            if self._stop_done:
+                return
+            try:
+                self.tracer.info("Stopping node")
+                if (
+                    self.command_handler is not None
+                    and self.command_loop is not None
+                    and not self.command_loop.cancelled()
+                ):
+                    self.tracer.info("Publishing node status to manager")
+                    await self.command_handler.client.publish(
+                        "manager/set_node_status",
+                        NodeStatus(
+                            status=NodeStatusEnum.DISCONNECTED
+                        ).SerializeToString(),
+                    )
+
+                if self.command_handler is not None:
+                    self.tracer.info("Cleaning up command handler")
+                    await self.command_handler.clean()
+            finally:
+                # Cancel the loops even if publish/clean raised, or they leak.
+                if self.command_loop is not None:
+                    self.tracer.info("Stopping command loop")
+                    self.command_loop.cancel()
+
+                if self.light_server_task is not None:
+                    self.tracer.info("Stopping light server task")
+                    self.light_server_task.cancel()
+            self._stop_done = True

manta_node/task_manager.py

@@ -302,9 +302,15 @@ class TaskManager:
         return updated
 
     async def get_task_status(self, swarm_id: ID, task_id: ID) -> TaskStatus:
+        if (swarm_id.tid, task_id.tid) in self.image_task_ids:
+            return await self.get_image_task_status(swarm_id, task_id)
         status = await self._executor.get_status(swarm_id, task_id)
         return TaskLifecycleService.calculate_status_from_container(status)
 
+    async def get_image_task_status(self, swarm_id: ID, task_id: ID) -> TaskStatus:
+        """Exit-code-aware status for image-mode tasks (no SDK inside the container)."""
+        return await self._executor.get_image_task_status(swarm_id, task_id)
+
     async def from_pending_to_running(self, task_progression: TaskProgression) -> bool:
         """
         Change a task progression from pending status (supposed) to running status

manta_node-0.6b0.dev534.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: manta_node
+Version: 0.6b0.dev534
+Summary: Node side software of the Manta platform. It is responsible for the communication with the Manta Core and the execution of the tasks.
+Author-email: Hugo Miralles <hugo.miralles@manta-tech.io>, Matthew Thompson <matthew.thompson@manta-tech.io>
+License-Expression: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/mantatech/manta-node-python
+Project-URL: Repository, https://github.com/mantatech/manta-node-python
+Classifier: Programming Language :: JavaScript
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Embedded Systems
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: grpcio-tools
+Requires-Dist: betterproto[compiler]==2.0.0b7
+Requires-Dist: pydantic<3.0.0,>=2.12.5
+Requires-Dist: docker
+Requires-Dist: rich
+Requires-Dist: cryptography>=50.0.0
+Requires-Dist: blake3
+Requires-Dist: aiodocker>=0.26.0
+Requires-Dist: pyyaml
+Requires-Dist: psutil
+Requires-Dist: msgpack
+Requires-Dist: aiomqtt<3.0,>=2.5.1
+Requires-Dist: manta-common-core<=0.6b0,>=0.6b0.dev0
+Requires-Dist: toml
+Requires-Dist: tomli; python_version < "3.11"
+Requires-Dist: tomli-w
+Requires-Dist: keyring
+Requires-Dist: wireguard-tools
+Requires-Dist: pyroute2
+Requires-Dist: icmplib
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: docs
+Requires-Dist: furo; extra == "docs"
+Provides-Extra: code-analytics
+Requires-Dist: ruff; extra == "code-analytics"
+Requires-Dist: pytest-cov; extra == "code-analytics"
+Requires-Dist: coverage-badge; extra == "code-analytics"
+Provides-Extra: all
+Requires-Dist: manta_node[code-analytics,docs,test]; extra == "all"
+Dynamic: license-file
+
+# Manta Node Python
+
+![Version](https://img.shields.io/badge/version-0.6b0-orange)
+![Python version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20-blue)
+![Coverage Badge](.github/coverage/coverage.svg)
+![Ruff](https://img.shields.io/badge/code_style-ruff-2a1833)
+
+## Overview
+
+Distributed edge execution agent for the Manta platform. Manages containerized task execution on compute nodes and provides local services to running tasks.
+
+## Quick Start
+
+```bash
+# Install
+pip install -e ".[all]"
+
+# Run node
+python -m manta_node --manager-host localhost --manager-port 50051 --token <jwt_token>
+
+# Run multiple nodes
+python -c "from manta_node import start_nodes; import asyncio; asyncio.run(start_nodes(3, 'localhost', 50051, '<jwt_token>'))"
+```
+
+## Documentation
+
+📚 **Full documentation is available at [docs.manta-tech.io](https://docs.manta-tech.io/)**
+
+- [Node Operator Guide](https://docs.manta-tech.io/node-guide/index.html)
+- [Node Configuration](https://docs.manta-tech.io/node-guide/configuration/index.html)
+- [Getting Started](https://docs.manta-tech.io/getting-started/index.html)
+- [Platform Overview](https://docs.manta-tech.io/core-concepts/index.html)
+
+For developers working on this component:
+
+- **[Node Architecture](https://github.com/mantatech/manta-deploy/blob/main/docs/components/node/ARCHITECTURE.md)** - Container orchestration, service implementation (lives in `mantatech/manta-deploy` per [ADR-0013](https://github.com/mantatech/manta-deploy/blob/main/docs/adr/0013-documentation-organization.md))
+- **[CLAUDE.md](./CLAUDE.md)** - Development guidelines
+
+## Architecture
+
+- **Container Management**: Docker-based task execution
+- **gRPC Services**: LocalServicer and WorldServicer for task communication
+- **MQTT Integration**: Asynchronous command reception
+- **Resource Monitoring**: Real-time metrics collection
+
+## Testing
+
+```bash
+python -m pytest tests/ --cov=manta_node
+```
+
+## Docker Setup
+
+For Linux users encountering permission issues:
+
+```bash
+# Follow Docker post-installation steps
+# https://docs.docker.com/engine/install/linux-postinstall/
+sudo usermod -aG docker $USER
+```
+
+## License
+
+GNU Affero General Public License

{manta_node-0.6b0.dev526.dist-info → manta_node-0.6b0.dev534.dist-info}/RECORD

@@ -1,7 +1,7 @@
 manta_node/__init__.py,sha256=bgGWXH3yQVhNf0v1ZGUBAy5Y51fqb0Y-EaLnocbcino,153
 manta_node/__main__.py,sha256=SjrJyuMg_ZFKV6WOVe3MrtWM8Qmu065dkKZYl4n2YLw,1665
-manta_node/node_orchestrator.py,sha256=O9xemhDWYzBoFIvOfCmxQlK-2X97xApHhbwe44StsFc,23134
-manta_node/task_manager.py,sha256=BkPUGtsEIiJDYhsBd3_qwMOJt7-YgZ6Y7sGqsK3uyDU,33043
+manta_node/node_orchestrator.py,sha256=Y1qOlyrXxk3znBidUagradrjiEVdl8BmgGRmtUYHTL8,24195
+manta_node/task_manager.py,sha256=l8EBQx5Spn2UISUK61WWqanefJF1_p2qGpxP8BeG_7Q,33428
 manta_node/tasks.py,sha256=o837Hi-KFVJg9LF5iOtE8oD6UuTOfrEPWR-JOdhRGeY,6983
 manta_node/utils.py,sha256=Hw4Iw2jYQYsfVLVJuBMt-_rMFBeml3nCDE2jiiXc8YM,1155
 manta_node/cli/__init__.py,sha256=arzO3mXDJ-E2yeeytbZfN7mCswwxdQ43_QjyeL2E5yE,134
@@ -13,7 +13,7 @@ manta_node/cli/commands/cluster.py,sha256=kUVopCN4xkEk-IR1aKpr7bfBSQEtG6pEj_hlWn
 manta_node/cli/commands/config.py,sha256=BiarCD0S8rcNYbio4RLzDvUS7A50s5dd5F4TiZqLR6M,16577
 manta_node/cli/commands/logs.py,sha256=cXOSdwhDIJAiKMmJYdzrnpapIxudxVdMzYT-KAWDKVk,5259
 manta_node/cli/commands/network.py,sha256=QqncD6vbNlg65ptQdFYexEUMALQm8UwcftbW3sfQrjw,42070
-manta_node/cli/commands/start.py,sha256=ZvoHP0PG26Um9zS3MIsqDLLLt0iQSsmcdvayalT7xyE,18392
+manta_node/cli/commands/start.py,sha256=8qpOTv4LsCAMaygmPyhC9ZqlH8rkFPko-u2bVYTvyIo,18771
 manta_node/cli/commands/status.py,sha256=FhlJuFxIRzxv9y8jUJRuWaCLfDBsGBqv6DCHUFQta3A,6401
 manta_node/cli/commands/stop.py,sha256=8on7NqqaBeHRcbrZ5pGJ3Ms_6E_HNcF22mZ908JVu4A,7695
 manta_node/domain/__init__.py,sha256=uyJXDf0QgfGCsXLMggqKCB5QV9oneYJ4iM-REaJGXDM,217
@@ -30,16 +30,16 @@ manta_node/infrastructure/container/executor.py,sha256=rl8eDyTVvoPJGnzA8XbY3ee_K
 manta_node/infrastructure/container/image_executor.py,sha256=ueLYGlMt1xuYCsuwYqf9HcitWgrWfieY0xq1vXZfCco,9987
 manta_node/infrastructure/container/manager.py,sha256=wJWBU160S6R4-R3B4eIg6p7ik2hCCeAll43wGs8Z8SY,15506
 manta_node/infrastructure/filesystem/__init__.py,sha256=nf6Fakp3wuFKjSAm_oihI6WE_yyUY6Uelr7A1GwSvXs,145
-manta_node/infrastructure/filesystem/dataset_manager.py,sha256=8aexrjrkWZ7OCuS0HkjYXZFtg_8Y5WOJ540inK7BYRs,14968
+manta_node/infrastructure/filesystem/dataset_manager.py,sha256=sW7vPKYBLjwbtju1yzFEob9GlY1v0VI-xu6gxF9KM90,15075
 manta_node/infrastructure/grpc/__init__.py,sha256=6I-yzQM42gdBfcZ1FPVEKF2-pgJMdW-UssDHgz2EFcc,254
-manta_node/infrastructure/grpc/client.py,sha256=8iocMLnGzPaOQmwR3X2sXPLCbOdbLjSZFsLgD1EZcsY,13177
+manta_node/infrastructure/grpc/client.py,sha256=f8z61BYfBChRW0IT5HKbIxypRfsxfCpTkX0Xsmw_vq8,13737
 manta_node/infrastructure/grpc/local_servicer.py,sha256=9PFAwpKKFGy3P7HZfx2BHwhOgZhWwkwEja-eUTnMfpw,4217
 manta_node/infrastructure/grpc/world_servicer.py,sha256=nmyrMzYxzGDlZ1-oOeyALgd76mbeOmAOsjzoVN6f0SA,8222
 manta_node/infrastructure/metrics/__init__.py,sha256=ODGAj9s63F5jba2c3dQRMfNK6I4WvMdcJUS_xApUN5Y,272
 manta_node/infrastructure/metrics/collector.py,sha256=9ESw__Pc2tV6ldG5yhos2IS7T5Td59KxTIwDRZc_G4w,3067
 manta_node/infrastructure/metrics/metrics_collector.py,sha256=TI_9tRoIUunGx_BstVavK6VElig7Wc5mJ0kB4bFumVs,11048
 manta_node/infrastructure/mqtt/__init__.py,sha256=riXo1sXgO4YV6DHCmWRqK61BAmuGLdHiVdQFunAJadA,140
-manta_node/infrastructure/mqtt/command_handler.py,sha256=2BP_HuIj6C8quVSLt4SwR4TuPnmpPWztmu0Vzd3RyLM,22975
+manta_node/infrastructure/mqtt/command_handler.py,sha256=WZgcOyzPJ5xgC6rrNumej3dd1LYDaWswlHWNSZJ9fYg,24528
 manta_node/infrastructure/network/__init__.py,sha256=On3XLgycFQoc-fBCa5hFuFDfEJjmFy7Wl2CK3D2LkdI,478
 manta_node/infrastructure/network/event_registry.py,sha256=iWEfUJRzDnWjOrDinpYqVyIUpGKJjp7RZkjMDPfpplM,1661
 manta_node/infrastructure/network/factory.py,sha256=-LvHbBp5nBpQ7fyQT1T0pvK3aczZqWc9QNDW37brBeU,3897
@@ -47,9 +47,9 @@ manta_node/infrastructure/network/protocols.py,sha256=U9AZM_R3Qizz0U-mIwC79jFDGW
 manta_node/infrastructure/network/wireguard_provider.py,sha256=1U4wbpxG3fQng6d5drqC0clzw26iLSYBlUWRbMyR00c,37923
 manta_node/infrastructure/process/__init__.py,sha256=MpKkA3k-6ND-Nb7uyzrpw8MdQssQQ6NaiUTLuLnzNbE,53
 manta_node/infrastructure/process/executor.py,sha256=Ab1XvNuelEGCD5KdZLgYYnpjYZ5dpKRKOzRWL68AxQg,11601
-manta_node-0.6b0.dev526.dist-info/licenses/LICENSE,sha256=9mBgLhiB9goQPQjg9XQJ6FjgVxYw9Q8lyOZYkPGwF_c,34484
-manta_node-0.6b0.dev526.dist-info/METADATA,sha256=G-hq2vfZiRdqtx2R8CNHFMjedXmZ4c9r1vGMtJFDEP8,43841
-manta_node-0.6b0.dev526.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-manta_node-0.6b0.dev526.dist-info/entry_points.txt,sha256=C_zcw6mdmztNxVUZGLZ83UH5TwcSuqb2C-rB4e2CQoc,56
-manta_node-0.6b0.dev526.dist-info/top_level.txt,sha256=nbT5J5WETuXM9UPoQckl29uUOq8wMYdRb9QDx5kAFeo,11
-manta_node-0.6b0.dev526.dist-info/RECORD,,
+manta_node-0.6b0.dev534.dist-info/licenses/LICENSE,sha256=9mBgLhiB9goQPQjg9XQJ6FjgVxYw9Q8lyOZYkPGwF_c,34484
+manta_node-0.6b0.dev534.dist-info/METADATA,sha256=SXyXZeplD4gYLl_9jqkeXOgv5Q4tGUjanKSFh5WQMpc,4213
+manta_node-0.6b0.dev534.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+manta_node-0.6b0.dev534.dist-info/entry_points.txt,sha256=C_zcw6mdmztNxVUZGLZ83UH5TwcSuqb2C-rB4e2CQoc,56
+manta_node-0.6b0.dev534.dist-info/top_level.txt,sha256=nbT5J5WETuXM9UPoQckl29uUOq8wMYdRb9QDx5kAFeo,11
+manta_node-0.6b0.dev534.dist-info/RECORD,,