daimon-sdk 0.4.2__tar.gz → 0.4.4__tar.gz

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: daimon-sdk
-Version: 0.4.2
+Version: 0.4.4
 Summary: Typed async Python SDK for daimon MCP services.
 Author: processd contributors
 License: MIT
@@ -113,15 +113,20 @@ print(read.file.content)
 - `await manager.health()`
 - `await manager.capacity()`
 - `await manager.create_sandbox()`
+- `await manager.find_sandbox(labels={"thread_id": thread_id})`
 - `await manager.find_or_create_sandbox(labels={"thread_id": thread_id})`
 - `await manager.get_sandbox(id)`
 - `await manager.start_sandbox(id) / stop_sandbox(id) / delete_sandbox(id)`
+- `await manager.update_sandbox(id, ttl_seconds=...)`
 - `async with manager.sandbox() as sandbox`
+- `await sandbox.set_ttl(ttl_seconds)`
 - `sandbox.runtime/files/exec/web/raw`
 
 `manager.sandbox()` creates a sandbox, connects to its MCP endpoint, and deletes
 it on context exit by default. Use `delete_on_exit=False` or
 `create_sandbox()` when the workspace should survive beyond the context.
+`ttl_seconds=0` marks a sandbox as immediately expired so the next manager
+reaper loop deletes it.
 
 ## Local Testing
 

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/README.md

@@ -99,15 +99,20 @@ print(read.file.content)
 - `await manager.health()`
 - `await manager.capacity()`
 - `await manager.create_sandbox()`
+- `await manager.find_sandbox(labels={"thread_id": thread_id})`
 - `await manager.find_or_create_sandbox(labels={"thread_id": thread_id})`
 - `await manager.get_sandbox(id)`
 - `await manager.start_sandbox(id) / stop_sandbox(id) / delete_sandbox(id)`
+- `await manager.update_sandbox(id, ttl_seconds=...)`
 - `async with manager.sandbox() as sandbox`
+- `await sandbox.set_ttl(ttl_seconds)`
 - `sandbox.runtime/files/exec/web/raw`
 
 `manager.sandbox()` creates a sandbox, connects to its MCP endpoint, and deletes
 it on context exit by default. Use `delete_on_exit=False` or
 `create_sandbox()` when the workspace should survive beyond the context.
+`ttl_seconds=0` marks a sandbox as immediately expired so the next manager
+reaper loop deletes it.
 
 ## Local Testing
 

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "daimon-sdk"
-version = "0.4.2"
+version = "0.4.4"
 description = "Typed async Python SDK for daimon MCP services."
 readme = "README.md"
 requires-python = ">=3.12"

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/src/daimon_sdk/manager.py

@@ -119,7 +119,7 @@ class DaimonSandbox:
     async def close(self) -> None:
         await self.client.close()
 
-    async def set_ttl(self, ttl_seconds: int | None) -> SandboxInfo:
+    async def set_ttl(self, ttl_seconds: int) -> SandboxInfo:
         self.info = await self._manager.update_sandbox(self.id, ttl_seconds=ttl_seconds)
         return self.info
 
@@ -241,6 +241,20 @@ class DaimonManagerClient:
         )
         return DaimonSandbox(self, info, timeout_s=self.timeout_s)
 
+    async def find_sandbox(
+        self,
+        *,
+        labels: dict[str, str],
+        ttl_seconds: int | None = None,
+    ) -> DaimonSandbox:
+        body: dict[str, Any] = {"labels": labels}
+        if ttl_seconds is not None:
+            body["ttl_seconds"] = ttl_seconds
+        info = SandboxInfo.from_dict(
+            await self._transport.json("POST", "/sandboxes/find", body=body)
+        )
+        return DaimonSandbox(self, info, timeout_s=self.timeout_s)
+
     async def get_sandbox(self, sandbox_id: str) -> SandboxInfo:
         return SandboxInfo.from_dict(await self._transport.json("GET", f"/sandboxes/{sandbox_id}"))
 
@@ -257,9 +271,18 @@ class DaimonManagerClient:
     async def delete_sandbox(self, sandbox_id: str) -> None:
         await self._transport.request("DELETE", f"/sandboxes/{sandbox_id}")
 
-    async def update_sandbox(self, sandbox_id: str, **updates: Any) -> SandboxInfo:
+    async def update_sandbox(
+        self,
+        sandbox_id: str,
+        *,
+        ttl_seconds: int | None = None,
+        **updates: Any,
+    ) -> SandboxInfo:
+        body = {key: value for key, value in updates.items() if value is not None}
+        if ttl_seconds is not None:
+            body["ttl_seconds"] = ttl_seconds
         return SandboxInfo.from_dict(
-            await self._transport.json("PATCH", f"/sandboxes/{sandbox_id}", body=updates)
+            await self._transport.json("PATCH", f"/sandboxes/{sandbox_id}", body=body or None)
         )
 
     def sandbox(self, *, delete_on_exit: bool = True) -> SandboxContext:

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/tests/test_e2e.py

@@ -13,7 +13,7 @@ from pathlib import Path
 import httpx
 import pytest
 
-from daimon_sdk import DaimonHttpError, DaimonManagerClient, DaimonToolError
+from daimon_sdk import DaimonConnectionError, DaimonHttpError, DaimonManagerClient, DaimonToolError
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 PROCESSD_ROOT = REPO_ROOT.parent / "processd-standalone"
@@ -219,8 +219,35 @@ async def test_background_bash_and_auth(auth_client) -> None:
         if "[process exited with code 0]" in final_text:
             break
         await asyncio.sleep(0.1)
+
     assert final_text is not None
     assert "start" in final_text
+    assert "end" in final_text
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(not MANAGER_E2E_ENABLED, reason="set PROCESSD_SDK_MANAGER_E2E=1")
+async def test_docker_manager_ttl_zero_expires_on_next_reaper_loop() -> None:
+    with _start_docker_manager(
+        extra_env={"PROCESSD_MANAGER_REAPER_INTERVAL_SECONDS": "1"}
+    ) as manager_url:
+        async with DaimonManagerClient(manager_url) as manager:
+            sandbox = await manager.create_sandbox()
+            updated = await sandbox.set_ttl(0)
+            assert updated.ttl_seconds == 0
+
+            deadline = time.monotonic() + 10
+            while time.monotonic() < deadline:
+                try:
+                    await manager.get_sandbox(sandbox.id)
+                except DaimonHttpError as exc:
+                    assert exc.status_code == 404
+                    break
+                except DaimonConnectionError:
+                    pass
+                await asyncio.sleep(1)
+            else:
+                raise AssertionError("sandbox was not reaped after ttl_seconds=0")
 
 
 @pytest.mark.manager_e2e

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/tests/test_unit.py

@@ -253,6 +253,13 @@ async def test_daimon_sandbox_lifecycle_updates_info_and_closes_client() -> None
         async def delete_sandbox(self, sandbox_id: str) -> None:
             self.deleted = sandbox_id
 
+        async def update_sandbox(self, sandbox_id: str, *, ttl_seconds: int | None = None, **updates) -> SandboxInfo:
+            payload = dict(SANDBOX_PAYLOAD)
+            payload["id"] = sandbox_id
+            payload["ttl_seconds"] = ttl_seconds
+            payload["expires_at"] = payload["last_used_at"] + ttl_seconds if ttl_seconds is not None else payload["expires_at"]
+            return SandboxInfo.from_dict(payload)
+
     manager = DummyManager()
     sandbox = DaimonSandbox(manager, SandboxInfo.from_dict(SANDBOX_PAYLOAD), timeout_s=30)
     first_client = DummyClient()
@@ -273,6 +280,63 @@ async def test_daimon_sandbox_lifecycle_updates_info_and_closes_client() -> None
     assert replacement_client.closed == 1
     assert sandbox.info.state == "deleted"
 
+    updated = await sandbox.set_ttl(0)
+    assert updated.ttl_seconds == 0
+    assert sandbox.info.ttl_seconds == 0
+
+
+@pytest.mark.asyncio
+async def test_manager_find_sandbox_posts_labels(monkeypatch) -> None:
+    from daimon_sdk.manager import DaimonManagerClient, DaimonSandbox
+
+    captured: dict[str, object] = {}
+
+    async def fake_json(method: str, path: str, *, body=None):
+        captured["method"] = method
+        captured["path"] = path
+        captured["body"] = body
+        return dict(SANDBOX_PAYLOAD)
+
+    manager = DaimonManagerClient("http://127.0.0.1:18080")
+    monkeypatch.setattr(manager._transport, "json", fake_json)
+
+    sandbox = await manager.find_sandbox(
+        labels={"thread_id": "thread-a"},
+        ttl_seconds=60,
+    )
+
+    assert isinstance(sandbox, DaimonSandbox)
+    assert sandbox.id == "sandbox-1"
+    assert captured == {
+        "method": "POST",
+        "path": "/sandboxes/find",
+        "body": {"labels": {"thread_id": "thread-a"}, "ttl_seconds": 60},
+    }
+
+
+@pytest.mark.asyncio
+async def test_manager_update_sandbox_omits_none_fields(monkeypatch) -> None:
+    from daimon_sdk.manager import DaimonManagerClient
+
+    captured: dict[str, object] = {}
+
+    async def fake_json(method: str, path: str, *, body=None):
+        captured["method"] = method
+        captured["path"] = path
+        captured["body"] = body
+        return dict(SANDBOX_PAYLOAD)
+
+    manager = DaimonManagerClient("http://127.0.0.1:18080")
+    monkeypatch.setattr(manager._transport, "json", fake_json)
+
+    await manager.update_sandbox("sandbox-1", ttl_seconds=0, note=None)
+
+    assert captured == {
+        "method": "PATCH",
+        "path": "/sandboxes/sandbox-1",
+        "body": {"ttl_seconds": 0},
+    }
+
 
 @pytest.mark.asyncio
 async def test_manager_sandbox_context_deletes_on_exception(monkeypatch) -> None:

{daimon_sdk-0.4.2 → daimon_sdk-0.4.4}/uv.lock

@@ -254,7 +254,7 @@ wheels = [
 
 [[package]]
 name = "daimon-sdk"
-version = "0.4.1"
+version = "0.4.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastmcp" },