daimon-sdk 0.4.7__tar.gz → 0.4.9__tar.gz

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: daimon-sdk
-Version: 0.4.7
+Version: 0.4.9
 Summary: Typed async Python SDK for daimon MCP services.
 Author: processd contributors
 License: MIT
@@ -113,6 +113,7 @@ print(read.file.content)
 - `await manager.health()`
 - `await manager.capacity()`
 - `await manager.create_sandbox()`
+- `await manager.list_sandboxes(labels=..., states=...)`
 - `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)`
@@ -127,6 +128,10 @@ print(read.file.content)
 `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.
+`find_sandbox(labels=...)` is a read-only lookup by default and does not extend
+the sandbox TTL. Pass `ttl_seconds=...` only when you intentionally want the
+manager's compatibility renew behavior, or use `find_or_create_sandbox(...)`
+for normal acquire/renew flows.
 `ttl_seconds=0` marks a sandbox as immediately expired so the next manager
 reaper loop deletes it.
 

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/README.md

@@ -99,6 +99,7 @@ print(read.file.content)
 - `await manager.health()`
 - `await manager.capacity()`
 - `await manager.create_sandbox()`
+- `await manager.list_sandboxes(labels=..., states=...)`
 - `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)`
@@ -113,6 +114,10 @@ print(read.file.content)
 `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.
+`find_sandbox(labels=...)` is a read-only lookup by default and does not extend
+the sandbox TTL. Pass `ttl_seconds=...` only when you intentionally want the
+manager's compatibility renew behavior, or use `find_or_create_sandbox(...)`
+for normal acquire/renew flows.
 `ttl_seconds=0` marks a sandbox as immediately expired so the next manager
 reaper loop deletes it.
 

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/pyproject.toml

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

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/src/daimon_sdk/__init__.py

@@ -18,6 +18,7 @@ from .models import (
     LimitsStatus,
     ManagerCapacityResult,
     RuntimeContextResult,
+    SandboxAction,
     SandboxInfo,
     ServicePortInfo,
     SessionHandle,
@@ -44,6 +45,7 @@ __all__ = [
     "LimitsStatus",
     "ManagerCapacityResult",
     "RuntimeContextResult",
+    "SandboxAction",
     "SandboxInfo",
     "ServicePortInfo",
     "SessionHandle",

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/src/daimon_sdk/manager.py

@@ -63,9 +63,10 @@ class ManagerHTTPTransport:
         method: str,
         path: str,
         *,
+        params: dict[str, Any] | None = None,
         body: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        response = await self.request(method, path, json=body)
+        response = await self.request(method, path, params=params, json=body)
         payload = response.json()
         if not isinstance(payload, dict):
             raise DaimonConnectionError(f"manager response was not a JSON object: {payload!r}")
@@ -241,6 +242,27 @@ class DaimonManagerClient:
         info = self._sandbox_info(await self._transport.json("POST", "/sandboxes"))
         return DaimonSandbox(self, info, timeout_s=self.timeout_s)
 
+    async def list_sandboxes(
+        self,
+        *,
+        labels: dict[str, str] | None = None,
+        states: list[str] | tuple[str, ...] | None = None,
+    ) -> list[SandboxInfo]:
+        params: dict[str, Any] = {}
+        if states:
+            params["state"] = list(states)
+        for key, value in (labels or {}).items():
+            params[f"label.{key}"] = value
+        payload = await self._transport.json(
+            "GET",
+            "/sandboxes",
+            params=params or None,
+        )
+        sandboxes = payload.get("sandboxes")
+        if not isinstance(sandboxes, list):
+            raise DaimonConnectionError("manager response missing sandboxes list")
+        return [self._sandbox_info(dict(item)) for item in sandboxes]
+
     async def find_or_create_sandbox(
         self,
         *,

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/src/daimon_sdk/models.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import time
 from dataclasses import dataclass, field
+from enum import StrEnum
 from typing import TYPE_CHECKING, Any
 from urllib.parse import urlsplit, urlunsplit
 
@@ -165,6 +166,21 @@ class ServicePortInfo:
         )
 
 
+class SandboxAction(StrEnum):
+    """Which branch an actuating manager endpoint took to produce a SandboxInfo.
+
+    Only set on `create`/`find-or-create`/`start`/`stop` responses; read-only
+    endpoints (`get`/`list`/`find`/`patch`) leave it ``None``.
+    """
+
+    CREATED = "created"
+    REUSED = "reused"
+    STARTED = "started"
+    ALREADY_RUNNING = "already_running"
+    STOPPED = "stopped"
+    ALREADY_STOPPED = "already_stopped"
+
+
 @dataclass(slots=True)
 class SandboxInfo:
     id: str
@@ -180,6 +196,7 @@ class SandboxInfo:
     ttl_seconds: int | None
     expires_at: int | None
     raw_payload: dict[str, Any]
+    action: SandboxAction | None = None
 
     @classmethod
     def from_dict(cls, payload: dict[str, Any], *, base_url: str | None = None) -> "SandboxInfo":
@@ -201,6 +218,7 @@ class SandboxInfo:
             ttl_seconds=_int_or_none(payload.get("ttl_seconds")),
             expires_at=_int_or_none(payload.get("expires_at")),
             raw_payload=dict(payload),
+            action=_action_or_none(payload.get("action")),
         )
 
 
@@ -262,6 +280,20 @@ def _int_or_none(value: Any) -> int | None:
     return None
 
 
+def _action_or_none(value: Any) -> SandboxAction | None:
+    """Leniently parse an ``action`` value; unknown/missing values become None.
+
+    Keeps older SDKs working if the manager later adds new action values. The
+    original string is always preserved in ``SandboxInfo.raw_payload``.
+    """
+    if value is None:
+        return None
+    try:
+        return SandboxAction(str(value))
+    except ValueError:
+        return None
+
+
 def _normalize_manager_proxy_url(url: str, base_url: str | None) -> str:
     if not base_url:
         return url

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/tests/test_unit.py

@@ -13,6 +13,7 @@ from daimon_sdk.manager import DaimonSandbox, ManagerHTTPTransport
 from daimon_sdk.models import (
     ExecResult,
     ManagerCapacityResult,
+    SandboxAction,
     SandboxInfo,
     SessionHandle,
 )
@@ -42,6 +43,7 @@ SANDBOX_PAYLOAD = {
     "last_used_at": 124,
     "ttl_seconds": 3600,
     "expires_at": 3724,
+    "action": "reused",
     "limits": {
         "rlimit": "applied",
         "cgroup": "applied",
@@ -197,6 +199,8 @@ def test_manager_models_parse_payloads() -> None:
     assert sandbox.labels["thread_id"] == "thread-a"
     assert sandbox.ttl_seconds == 3600
     assert sandbox.expires_at == 3724
+    assert sandbox.action == SandboxAction.REUSED
+    assert sandbox.action == "reused"
     assert sandbox.raw_payload["mcp_url"] == SANDBOX_PAYLOAD["mcp_url"]
     assert len(sandbox.service_ports) == 2
     assert sandbox.service_ports[0].port == 3000
@@ -216,6 +220,34 @@ def test_manager_models_parse_payloads() -> None:
     assert capacity.raw_payload["capacity_source"] == "/sys/fs/cgroup/test"
 
 
+def test_sandbox_info_action_defaults_to_none_when_missing() -> None:
+    payload = {key: value for key, value in SANDBOX_PAYLOAD.items() if key != "action"}
+    sandbox = SandboxInfo.from_dict(payload)
+    assert sandbox.action is None
+
+
+def test_sandbox_info_action_is_none_for_unknown_value() -> None:
+    payload = {**SANDBOX_PAYLOAD, "action": "some_future_action"}
+    sandbox = SandboxInfo.from_dict(payload)
+    assert sandbox.action is None
+    assert sandbox.raw_payload["action"] == "some_future_action"
+
+
+@pytest.mark.parametrize("action", list(SandboxAction))
+def test_sandbox_info_action_round_trips_all_wire_values(action: SandboxAction) -> None:
+    payload = {**SANDBOX_PAYLOAD, "action": action.value}
+    sandbox = SandboxInfo.from_dict(payload)
+    assert sandbox.action is action
+    assert sandbox.action == action.value
+
+
+@pytest.mark.parametrize("bad_value", [0, 1, True, ["reused"], {"a": 1}, b"reused"])
+def test_sandbox_info_action_is_none_for_non_string_values(bad_value) -> None:
+    payload = {**SANDBOX_PAYLOAD, "action": bad_value}
+    sandbox = SandboxInfo.from_dict(payload)
+    assert sandbox.action is None
+
+
 def test_sandbox_info_rewrites_localhost_proxy_urls_from_manager_base_url() -> None:
     sandbox = SandboxInfo.from_dict(
         SANDBOX_PAYLOAD,
@@ -338,7 +370,70 @@ async def test_daimon_sandbox_lifecycle_updates_info_and_closes_client() -> None
 
 
 @pytest.mark.asyncio
-async def test_manager_find_sandbox_posts_labels(monkeypatch) -> None:
+async def test_manager_list_sandboxes_gets_filtered_sandbox_list(monkeypatch) -> None:
+    from daimon_sdk.manager import DaimonManagerClient
+
+    captured: dict[str, object] = {}
+    second = dict(SANDBOX_PAYLOAD)
+    second["id"] = "sandbox-2"
+    second["state"] = "stopped"
+
+    async def fake_json(method: str, path: str, *, params=None, body=None):
+        captured["method"] = method
+        captured["path"] = path
+        captured["params"] = params
+        captured["body"] = body
+        return {"sandboxes": [dict(SANDBOX_PAYLOAD), second]}
+
+    manager = DaimonManagerClient("http://127.0.0.1:18080")
+    monkeypatch.setattr(manager._transport, "json", fake_json)
+
+    sandboxes = await manager.list_sandboxes(
+        labels={"thread_id": "thread-a"},
+        states=["running", "stopped"],
+    )
+
+    assert [sandbox.id for sandbox in sandboxes] == ["sandbox-1", "sandbox-2"]
+    assert sandboxes[1].state == "stopped"
+    assert captured == {
+        "method": "GET",
+        "path": "/sandboxes",
+        "params": {
+            "state": ["running", "stopped"],
+            "label.thread_id": "thread-a",
+        },
+        "body": None,
+    }
+
+
+@pytest.mark.asyncio
+async def test_manager_find_sandbox_posts_labels_without_ttl_by_default(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"})
+
+    assert isinstance(sandbox, DaimonSandbox)
+    assert sandbox.id == "sandbox-1"
+    assert captured == {
+        "method": "POST",
+        "path": "/sandboxes/find",
+        "body": {"labels": {"thread_id": "thread-a"}},
+    }
+
+
+@pytest.mark.asyncio
+async def test_manager_find_sandbox_posts_explicit_ttl_for_compat_refresh(monkeypatch) -> None:
     from daimon_sdk.manager import DaimonManagerClient, DaimonSandbox
 
     captured: dict[str, object] = {}

{daimon_sdk-0.4.7 → daimon_sdk-0.4.9}/uv.lock

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