agentix-deployment-docker 0.1.1__py3-none-any.whl

agentix/deployment/docker.py

@@ -0,0 +1,122 @@
+"""Docker deployment: sandbox CRUD via local Docker.
+
+Design:
+
+  Bundle images are produced by `agentix build` and are self-contained:
+  they ship the runtime + every namespace's Python package in one venv,
+  plus any system deps under `/nix`. The deployment runs the bundle
+  image directly — no volume populate, no mount-and-merge, no custom
+  entrypoint.
+
+  Sandbox create:
+      docker run -d --name <sid> --network host \\
+         -e AGENTIX_BIND_PORT=<port> \\
+         <bundle-image>
+
+  The container's `ENTRYPOINT` is `agentix-server`, which binds to the
+  port from the env var. We pick a free host port, pass it through, and
+  health-check `/health` on it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import socket
+from uuid import uuid4
+
+import httpx
+
+from agentix.deployment.base import Deployment, Sandbox
+from agentix.idents import SandboxId
+from agentix.models import SandboxConfig, SandboxInfo
+
+logger = logging.getLogger("agentix.deployment.docker")
+
+
+async def _docker(*args: str, check: bool = True) -> tuple[int, bytes, bytes]:
+    proc = await asyncio.create_subprocess_exec(
+        "docker", *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    rc = proc.returncode or 0
+    if check and rc != 0:
+        raise RuntimeError(f"docker {args[0]} failed: {stderr.decode(errors='replace')}")
+    return rc, stdout, stderr
+
+
+class DockerDeployment(Deployment):
+    """Sandbox CRUD via local Docker."""
+
+    def __init__(self):
+        self._ports: dict[SandboxId, int] = {}  # sandbox_id → host port
+
+    @staticmethod
+    def _allocate_port() -> int:
+        # Ask the kernel for any free TCP port. There's still a small
+        # TOCTOU window before the container binds, but no worse than a
+        # linear probe and without the seed parameter.
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("127.0.0.1", 0))
+            return s.getsockname()[1]
+
+    async def create(self, config: SandboxConfig) -> Sandbox:
+        sandbox_id = SandboxId(f"agentix-{uuid4().hex[:8]}")
+        port = self._allocate_port()
+
+        env_args: list[str] = ["-e", f"AGENTIX_BIND_PORT={port}"]
+        if config.env:
+            for k, v in config.env.items():
+                env_args.extend(["-e", f"{k}={v}"])
+
+        await _docker(
+            "run", "-d",
+            "--name", sandbox_id,
+            "--network", "host",
+            *env_args,
+            config.image,
+        )
+
+        self._ports[sandbox_id] = port
+        logger.info("Created sandbox %s on port %d", sandbox_id, port)
+
+        await self._wait_healthy(port)
+        return Sandbox(
+            sandbox_id=sandbox_id,
+            runtime_url=f"http://localhost:{port}",
+            status="running",
+        )
+
+    async def _wait_healthy(self, port: int) -> None:
+        base_url = f"http://localhost:{port}"
+        async with httpx.AsyncClient(base_url=base_url, timeout=60) as client:
+            for _ in range(120):
+                try:
+                    r = await client.get("/health")
+                    if r.status_code == 200:
+                        return
+                except (httpx.ConnectError, httpx.ReadError, httpx.RemoteProtocolError):
+                    pass
+                await asyncio.sleep(0.5)
+        raise TimeoutError(f"Runtime server not alive at {base_url}")
+
+    async def get(self, sandbox_id: SandboxId) -> SandboxInfo:
+        port = self._ports.get(sandbox_id)
+        if port is None:
+            raise KeyError(f"Sandbox not found: {sandbox_id}")
+        rc, stdout, _ = await _docker(
+            "inspect", "-f", "{{.State.Status}}", sandbox_id, check=False,
+        )
+        status = stdout.decode().strip() if rc == 0 else "unknown"
+        return SandboxInfo(
+            sandbox_id=sandbox_id,
+            runtime_url=f"http://localhost:{port}",
+            status=status,
+        )
+
+    async def delete(self, sandbox_id: SandboxId) -> None:
+        await _docker("rm", "-f", sandbox_id, check=False)
+        self._ports.pop(sandbox_id, None)
+        logger.info("Deleted sandbox %s", sandbox_id)

agentix_deployment_docker-0.1.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: agentix-deployment-docker
+Version: 0.1.1
+Summary: Docker deployment backend for Agentix
+Project-URL: Homepage, https://github.com/Agentiix/Agentix-Deployment-Docker
+Author: Agentiix
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: agentixx>=0.1.0
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.380; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agentix-deployment-docker
+
+Docker deployment backend for [Agentix](https://github.com/Agentiix/Agentix).
+
+Provisions a sandbox by running an Agentix bundle image in a local
+Docker daemon, returns the runtime URL the orchestrator's
+`RuntimeClient` connects to.
+
+## Install
+
+```bash
+pip install agentix-deployment-docker
+```
+
+## Use
+
+```python
+from agentix import RuntimeClient, SandboxConfig
+from agentix.deployment.docker import DockerDeployment
+
+async with DockerDeployment().lifecycle(
+    SandboxConfig(image="my-agent:0.1.0")
+) as sandbox:
+    async with RuntimeClient(sandbox.runtime_url) as c:
+        ...
+```
+
+Or via the CLI:
+
+```bash
+agentix deploy local --image my-agent:0.1.0
+```
+
+The `local` name comes from the entry point this wheel declares under
+`agentix.deployment` — once installed, the framework discovers it
+automatically. No core-framework changes are required to register a new
+backend; the same pattern works for `agentix-deployment-daytona`,
+`agentix-deployment-e2b`, or any third-party backend.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

agentix_deployment_docker-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+agentix/deployment/docker.py,sha256=5REOsUa8cfgRLEvfSU-kUEcZYCnlt-J-lx6Vv7-hL_o,4196
+agentix_deployment_docker-0.1.1.dist-info/METADATA,sha256=cAq_fZYmsPz2qPxW1fSNrjZfwdOy5jMylSLRYNld6Os,1638
+agentix_deployment_docker-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentix_deployment_docker-0.1.1.dist-info/entry_points.txt,sha256=XZvz5CURq-FLRHLq03zO6OtK05fwu_pZhh3i83MfD0M,72
+agentix_deployment_docker-0.1.1.dist-info/licenses/LICENSE,sha256=mt35xkyIDkKZlEgxp-WYN0zaNDhtZtYtagSi6rMQmXg,1065
+agentix_deployment_docker-0.1.1.dist-info/RECORD,,

agentix_deployment_docker-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentix_deployment_docker-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[agentix.deployment]
+local = agentix.deployment.docker:DockerDeployment

agentix_deployment_docker-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agentiix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.