dominus-sdk-python 6.0.0__tar.gz → 6.0.1__tar.gz

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 6.0.0
+Version: 6.0.1
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
-License: Proprietary
+License-Expression: LicenseRef-Proprietary
 Project-URL: Homepage, https://github.com/carebridgesystems/dominus-sdk-python
 Project-URL: Repository, https://github.com/carebridgesystems/dominus-sdk-python
 Keywords: dominus,carebridge,sdk,gateway,api,async
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/dominus/__init__.py

@@ -112,6 +112,8 @@ from .namespaces.browser import BrowserNamespace
 from .namespaces.recipes import RecipesNamespace
 from .namespaces.deployer import DeployerNamespace
 from .namespaces.warden import WardenNamespace
+from .namespaces.platform import PlatformNamespace
+from .namespaces.coder import CoderNamespace
 
 # Export AI namespace for agent-runtime operations
 from .namespaces.ai import (
@@ -162,7 +164,7 @@ from .errors import (
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "6.0.0"
+__version__ = "6.0.1"
 __all__ = [
     # Main SDK instance
     "dominus",
@@ -213,6 +215,8 @@ __all__ = [
     "RecipesNamespace",
     "DeployerNamespace",
     "WardenNamespace",
+    "PlatformNamespace",
+    "CoderNamespace",
     # AI namespace for agent-runtime operations
     "AiNamespace",
     "RagSubNamespace",

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/dominus/namespaces/__init__.py

@@ -19,6 +19,8 @@ from .browser import BrowserNamespace
 from .recipes import RecipesNamespace
 from .deployer import DeployerNamespace
 from .warden import WardenNamespace
+from .platform import PlatformNamespace
+from .coder import CoderNamespace
 from .ai import (
     AiNamespace,
     RagSubNamespace,
@@ -48,6 +50,8 @@ __all__ = [
     "RecipesNamespace",
     "DeployerNamespace",
     "WardenNamespace",
+    "PlatformNamespace",
+    "CoderNamespace",
     "AiNamespace",
     "RagSubNamespace",
     "ArtifactsSubNamespace",

dominus_sdk_python-6.0.1/dominus/namespaces/coder.py

@@ -0,0 +1,221 @@
+"""Coder namespace.
+
+Lifecycle helpers for dominus-coder-runtime. This surface intentionally avoids
+raw shell, filesystem browsing, and credential ingress helpers; Platform
+decisions and Coder Runtime own executor policy and workspace operations.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, TYPE_CHECKING
+from urllib.parse import quote, urlencode
+
+if TYPE_CHECKING:
+    from ..start import Dominus
+
+
+def _compact(payload: Dict[str, Any]) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    for key, value in payload.items():
+        if value is None:
+            continue
+        if isinstance(value, str) and value.strip() == "":
+            continue
+        out[key] = value
+    return out
+
+
+def _query_string(params: Dict[str, Any]) -> str:
+    cleaned = _compact(params)
+    return f"?{urlencode(cleaned)}" if cleaned else ""
+
+
+def _normalize_coder_path(path: str) -> str:
+    trimmed = path.strip()
+    normalized = trimmed if trimmed.startswith("/") else f"/{trimmed}"
+    if normalized == "/svc/coder" or normalized.startswith("/svc/coder/"):
+        return normalized
+    if normalized == "/api/coder" or normalized.startswith("/api/coder/"):
+        return normalized.replace("/api/", "/svc/", 1)
+    return f"/svc/coder{normalized}"
+
+
+def _mutation_body(
+    *,
+    reason: Optional[str] = None,
+    idempotency_key: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    return _compact(
+        {
+            "reason": reason,
+            "idempotency_key": idempotency_key,
+            "metadata": metadata,
+        }
+    )
+
+
+class CoderNamespace:
+    """Coder run lifecycle helpers."""
+
+    def __init__(self, client: "Dominus"):
+        self._client = client
+
+    async def request(
+        self,
+        path: str,
+        *,
+        method: str = "GET",
+        body: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: float = 30.0,
+    ) -> Any:
+        return await self._client.gateway_fetch(
+            _normalize_coder_path(path),
+            method=method,
+            body=body,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    async def health(self) -> Dict[str, Any]:
+        return await self.request("/health", method="GET")
+
+    async def ready(self) -> Dict[str, Any]:
+        return await self.request("/ready", method="GET")
+
+    async def ensure_run(
+        self,
+        *,
+        policy_decision_id: str,
+        idempotency_key: Optional[str] = None,
+        mode: Optional[str] = None,
+        task_recipe_ref: Optional[str] = None,
+        workflow_recipe_ref: Optional[str] = None,
+        pipeline_recipe_ref: Optional[str] = None,
+        group: Optional[str] = None,
+        repository: Optional[str] = None,
+        branch: Optional[str] = None,
+        base_branch: Optional[str] = None,
+        working_branch: Optional[str] = None,
+        title: Optional[str] = None,
+        instructions: Optional[str] = None,
+        inputs: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        if not policy_decision_id or policy_decision_id.strip() == "":
+            raise ValueError("ensure_run requires policy_decision_id")
+
+        body = _compact(
+            {
+                "policy_decision_id": policy_decision_id,
+                "idempotency_key": idempotency_key,
+                "mode": mode,
+                "task_recipe_ref": task_recipe_ref,
+                "workflow_recipe_ref": workflow_recipe_ref,
+                "pipeline_recipe_ref": pipeline_recipe_ref,
+                "group": group,
+                "repository": repository,
+                "branch": branch,
+                "base_branch": base_branch,
+                "working_branch": working_branch,
+                "title": title,
+                "instructions": instructions,
+                "inputs": inputs,
+                "metadata": metadata,
+            }
+        )
+        return await self.request(
+            "/runs/ensure",
+            method="POST",
+            body=body,
+            timeout=600.0,
+        )
+
+    async def list_runs(
+        self,
+        *,
+        status: Optional[str] = None,
+        group: Optional[str] = None,
+        repository: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        qs = _query_string(
+            {
+                "status": status,
+                "group": group,
+                "repository": repository,
+                "limit": limit,
+                "offset": offset,
+            }
+        )
+        return await self.request(f"/runs{qs}", method="GET")
+
+    async def get_run(self, run_id: str) -> Dict[str, Any]:
+        return await self.request(f"/runs/{quote(run_id, safe='')}", method="GET")
+
+    async def cancel_run(
+        self,
+        run_id: str,
+        *,
+        reason: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return await self.request(
+            f"/runs/{quote(run_id, safe='')}/cancel",
+            method="POST",
+            body=_mutation_body(
+                reason=reason,
+                idempotency_key=idempotency_key,
+                metadata=metadata,
+            ),
+        )
+
+    async def retry_run(
+        self,
+        run_id: str,
+        *,
+        reason: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return await self.request(
+            f"/runs/{quote(run_id, safe='')}/retry",
+            method="POST",
+            body=_mutation_body(
+                reason=reason,
+                idempotency_key=idempotency_key,
+                metadata=metadata,
+            ),
+        )
+
+    async def nudge_run(
+        self,
+        run_id: str,
+        *,
+        reason: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return await self.request(
+            f"/runs/{quote(run_id, safe='')}/nudge",
+            method="POST",
+            body=_mutation_body(
+                reason=reason,
+                idempotency_key=idempotency_key,
+                metadata=metadata,
+            ),
+        )
+
+    async def get_run_summary(self, run_id: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/runs/{quote(run_id, safe='')}/summary",
+            method="GET",
+        )
+
+    async def get_run_artifacts(self, run_id: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/runs/{quote(run_id, safe='')}/artifacts",
+            method="GET",
+        )

dominus_sdk_python-6.0.1/dominus/namespaces/platform.py

@@ -0,0 +1,130 @@
+"""Platform namespace.
+
+Thin JSON-first helpers for the dominus-platform-worker Gateway surface.
+Platform owns group/repository policy decisions; it does not execute coder work
+or expose credentials.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, TYPE_CHECKING
+from urllib.parse import quote
+
+if TYPE_CHECKING:
+    from ..start import Dominus
+
+
+def _normalize_platform_path(path: str) -> str:
+    trimmed = path.strip()
+    normalized = trimmed if trimmed.startswith("/") else f"/{trimmed}"
+    if normalized == "/svc/platform" or normalized.startswith("/svc/platform/"):
+        return normalized
+    if normalized == "/api/platform" or normalized.startswith("/api/platform/"):
+        return normalized.replace("/api/", "/svc/", 1)
+    return f"/svc/platform{normalized}"
+
+
+class PlatformNamespace:
+    """Platform group/repository policy helpers."""
+
+    def __init__(self, client: "Dominus"):
+        self._client = client
+
+    async def request(
+        self,
+        path: str,
+        *,
+        method: str = "GET",
+        body: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: float = 30.0,
+    ) -> Any:
+        return await self._client.gateway_fetch(
+            _normalize_platform_path(path),
+            method=method,
+            body=body,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    async def health(self) -> Dict[str, Any]:
+        return await self.request("/health", method="GET")
+
+    async def ready(self) -> Dict[str, Any]:
+        return await self.request("/ready", method="GET")
+
+    async def list_groups(self) -> Dict[str, Any]:
+        return await self.request("/groups", method="GET")
+
+    async def get_group(self, group_slug: str) -> Dict[str, Any]:
+        return await self.request(f"/groups/{quote(group_slug, safe='')}", method="GET")
+
+    async def upsert_group(self, group: Dict[str, Any]) -> Dict[str, Any]:
+        return await self.request("/groups", method="POST", body=group)
+
+    async def update_group(self, group_slug: str, group: Dict[str, Any]) -> Dict[str, Any]:
+        return await self.request(
+            f"/groups/{quote(group_slug, safe='')}",
+            method="PATCH",
+            body=group,
+        )
+
+    async def add_group_member(self, group_slug: str, subject_id: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/groups/{quote(group_slug, safe='')}/members",
+            method="POST",
+            body={"subject_id": subject_id},
+        )
+
+    async def link_group_repository(self, group_slug: str, repository: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/groups/{quote(group_slug, safe='')}/repositories",
+            method="POST",
+            body={"repository": repository},
+        )
+
+    async def list_repositories(self) -> Dict[str, Any]:
+        return await self.request("/repositories", method="GET")
+
+    async def get_repository(self, repository_id: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/repositories/{quote(repository_id, safe='')}",
+            method="GET",
+        )
+
+    async def upsert_repository(self, repository: Dict[str, Any]) -> Dict[str, Any]:
+        return await self.request("/repositories", method="POST", body=repository)
+
+    async def update_repository(
+        self,
+        repository_id: str,
+        repository: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        return await self.request(
+            f"/repositories/{quote(repository_id, safe='')}",
+            method="PATCH",
+            body=repository,
+        )
+
+    async def ensure_policy_decision(self, options: Dict[str, Any]) -> Dict[str, Any]:
+        return await self.request(
+            "/policy/decisions/ensure",
+            method="POST",
+            body=options,
+        )
+
+    async def get_policy_decision(self, decision_id: str) -> Dict[str, Any]:
+        return await self.request(
+            f"/policy/decisions/{quote(decision_id, safe='')}",
+            method="GET",
+        )
+
+    async def rehydrate_policy_decision(
+        self,
+        decision_id: str,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return await self.request(
+            f"/policy/decisions/{quote(decision_id, safe='')}/rehydrate",
+            method="POST",
+            body=options or {},
+        )

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/dominus/start.py

@@ -179,8 +179,12 @@ class Dominus:
         # Thin operator control-plane namespaces (Mothership / MCP parity)
         from .namespaces.deployer import DeployerNamespace
         from .namespaces.warden import WardenNamespace
+        from .namespaces.platform import PlatformNamespace
+        from .namespaces.coder import CoderNamespace
         self.deployer = DeployerNamespace(self)
         self.warden = WardenNamespace(self)
+        self.platform = PlatformNamespace(self)
+        self.coder = CoderNamespace(self)
 
         # Stash worker (per-scope durable items: credentials + configs)
         from .namespaces.stash import StashNamespace

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/dominus_sdk_python.egg-info/PKG-INFO

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 6.0.0
+Version: 6.0.1
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
-License: Proprietary
+License-Expression: LicenseRef-Proprietary
 Project-URL: Homepage, https://github.com/carebridgesystems/dominus-sdk-python
 Project-URL: Repository, https://github.com/carebridgesystems/dominus-sdk-python
 Keywords: dominus,carebridge,sdk,gateway,api,async
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/dominus_sdk_python.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ dominus/namespaces/artifacts.py
 dominus/namespaces/auth.py
 dominus/namespaces/authority.py
 dominus/namespaces/browser.py
+dominus/namespaces/coder.py
 dominus/namespaces/courier.py
 dominus/namespaces/db.py
 dominus/namespaces/ddl.py
@@ -29,6 +30,7 @@ dominus/namespaces/files.py
 dominus/namespaces/health.py
 dominus/namespaces/jobs.py
 dominus/namespaces/logs.py
+dominus/namespaces/platform.py
 dominus/namespaces/portal.py
 dominus/namespaces/processor.py
 dominus/namespaces/recipes.py
@@ -53,6 +55,7 @@ tests/test_errors.py
 tests/test_flat_commands.py
 tests/test_health.py
 tests/test_logs.py
+tests/test_platform_coder_namespaces.py
 tests/test_provisioning_parity.py
 tests/test_public_exports.py
 tests/test_recipes_namespace.py

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/pyproject.toml

@@ -1,13 +1,13 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools>=77.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "6.0.0"
+version = "6.0.1"
 description = "Python SDK for the Dominus gateway-first platform"
 readme = "README.md"
-license = {text = "Proprietary"}
+license = "LicenseRef-Proprietary"
 requires-python = ">=3.9"
 authors = [
     {name = "CareBridge Systems", email = "dev@carebridge.io"}
@@ -16,7 +16,6 @@ keywords = ["dominus", "carebridge", "sdk", "gateway", "api", "async"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "License :: Other/Proprietary License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",

dominus_sdk_python-6.0.1/tests/test_platform_coder_namespaces.py

@@ -0,0 +1,118 @@
+import pytest
+
+from dominus.namespaces.coder import CoderNamespace
+from dominus.namespaces.platform import PlatformNamespace
+
+
+class MockGatewayClient:
+    def __init__(self):
+        self.calls = []
+
+    async def gateway_fetch(self, path, **kwargs):
+        self.calls.append((path, kwargs))
+        return {"ok": True}
+
+
+@pytest.mark.asyncio
+async def test_platform_namespace_normalizes_helpers_onto_service_routes():
+    client = MockGatewayClient()
+    platform = PlatformNamespace(client)
+
+    await platform.health()
+    await platform.list_groups()
+    await platform.upsert_group({"slug": "dominus", "name": "Dominus"})
+    await platform.add_group_member("dominus", "user-1")
+    await platform.link_group_repository(
+        "dominus",
+        "carebridgesystems/dominus-platform-worker",
+    )
+    await platform.ensure_policy_decision(
+        {
+            "group": "dominus",
+            "repository": "carebridgesystems/dominus-platform-worker",
+            "metadata": {"safe": "ok"},
+        }
+    )
+    await platform.rehydrate_policy_decision("pd_123", {"run_id": "run_123"})
+
+    assert [(path, kwargs["method"]) for path, kwargs in client.calls] == [
+        ("/svc/platform/health", "GET"),
+        ("/svc/platform/groups", "GET"),
+        ("/svc/platform/groups", "POST"),
+        ("/svc/platform/groups/dominus/members", "POST"),
+        ("/svc/platform/groups/dominus/repositories", "POST"),
+        ("/svc/platform/policy/decisions/ensure", "POST"),
+        ("/svc/platform/policy/decisions/pd_123/rehydrate", "POST"),
+    ]
+    assert client.calls[2][1]["body"] == {"slug": "dominus", "name": "Dominus"}
+    assert client.calls[3][1]["body"] == {"subject_id": "user-1"}
+    assert client.calls[5][1]["body"] == {
+        "group": "dominus",
+        "repository": "carebridgesystems/dominus-platform-worker",
+        "metadata": {"safe": "ok"},
+    }
+
+
+@pytest.mark.asyncio
+async def test_platform_request_preserves_explicit_platform_paths():
+    client = MockGatewayClient()
+    platform = PlatformNamespace(client)
+
+    await platform.request("/api/platform/groups", method="GET")
+    await platform.request("/svc/platform/policy/decisions/pd_123", method="GET")
+
+    assert [path for path, _ in client.calls] == [
+        "/svc/platform/groups",
+        "/svc/platform/policy/decisions/pd_123",
+    ]
+
+
+@pytest.mark.asyncio
+async def test_coder_namespace_exposes_lifecycle_helpers_but_no_raw_shell():
+    client = MockGatewayClient()
+    coder = CoderNamespace(client)
+
+    await coder.ensure_run(
+        policy_decision_id="pd_123",
+        mode="async",
+        task_recipe_ref="recipe://coder-task-recipe-v1/fix-tests@head",
+        repository="carebridgesystems/dominus-platform-worker",
+        instructions="Fix failing tests",
+    )
+    await coder.list_runs(status="running", limit=10)
+    await coder.cancel_run("run_123", reason="operator requested")
+    await coder.retry_run("run_123", idempotency_key="retry-1")
+    await coder.nudge_run("run_123", metadata={"hint": "continue"})
+    await coder.get_run_summary("run_123")
+    await coder.get_run_artifacts("run_123")
+
+    assert [(path, kwargs["method"]) for path, kwargs in client.calls] == [
+        ("/svc/coder/runs/ensure", "POST"),
+        ("/svc/coder/runs?status=running&limit=10", "GET"),
+        ("/svc/coder/runs/run_123/cancel", "POST"),
+        ("/svc/coder/runs/run_123/retry", "POST"),
+        ("/svc/coder/runs/run_123/nudge", "POST"),
+        ("/svc/coder/runs/run_123/summary", "GET"),
+        ("/svc/coder/runs/run_123/artifacts", "GET"),
+    ]
+    assert client.calls[0][1]["body"] == {
+        "policy_decision_id": "pd_123",
+        "mode": "async",
+        "task_recipe_ref": "recipe://coder-task-recipe-v1/fix-tests@head",
+        "repository": "carebridgesystems/dominus-platform-worker",
+        "instructions": "Fix failing tests",
+    }
+    assert not hasattr(coder, "shell")
+    assert not hasattr(coder, "exec")
+    assert not hasattr(coder, "command")
+
+
+@pytest.mark.asyncio
+async def test_coder_ensure_run_requires_policy_decision_id():
+    client = MockGatewayClient()
+    coder = CoderNamespace(client)
+
+    with pytest.raises(ValueError, match="policy_decision_id"):
+        await coder.ensure_run(policy_decision_id="")
+
+    assert client.calls == []

{dominus_sdk_python-6.0.0 → dominus_sdk_python-6.0.1}/tests/test_public_exports.py

@@ -1,6 +1,8 @@
 from dominus import (
     BrowserNamespace,
+    CoderNamespace,
     DeployerNamespace,
+    PlatformNamespace,
     RecipesNamespace,
     WardenNamespace,
     gateway_circuit_breaker,
@@ -33,6 +35,8 @@ def test_top_level_exports_drop_delegate_alias():
     assert WardenNamespace is not None
     assert BrowserNamespace is not None
     assert RecipesNamespace is not None
+    assert PlatformNamespace is not None
+    assert CoderNamespace is not None
 
 
 def test_singleton_exposes_browser_namespace():
@@ -40,3 +44,5 @@ def test_singleton_exposes_browser_namespace():
 
     assert callable(dominus.browser.get_health)
     assert callable(dominus.recipes.list_types)
+    assert callable(dominus.platform.ensure_policy_decision)
+    assert callable(dominus.coder.ensure_run)