dcc-mcp-runtime 0.2.0__py3-none-any.whl

dcc_mcp_runtime/__init__.py

@@ -0,0 +1,17 @@
+"""Shared runtime contracts for external DCC-MCP adapters."""
+
+from .handshake import CapabilityHandshake, HandshakeResult, negotiate
+from .lifecycle import InstallPlan, InstallResult, plan_install
+from .manifest import AdapterManifest, RuntimeManifest, load_manifest
+
+__all__ = [
+    "AdapterManifest",
+    "CapabilityHandshake",
+    "HandshakeResult",
+    "InstallPlan",
+    "InstallResult",
+    "RuntimeManifest",
+    "load_manifest",
+    "negotiate",
+    "plan_install",
+]

dcc_mcp_runtime/bootstrap.py

@@ -0,0 +1,38 @@
+"""Compatibility bootstrap used by external adapter entry points.
+
+It performs only manifest loading and negotiation. Process spawning, host UI
+control and installer execution remain owned by each adapter/core.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .handshake import HandshakeResult, negotiate
+from .manifest import AdapterManifest, RuntimeManifest, load_manifest
+
+
+def runtime_root() -> Path:
+    """Resolve the side-by-side runtime root without consulting the shell."""
+    configured = os.environ.get("DCC_MCP_RUNTIME_ROOT")
+    if configured:
+        return Path(configured).resolve()
+    # Installed package: <root>/lib/site-packages/dcc_mcp_runtime.
+    return Path(__file__).resolve().parents[3]
+
+
+def negotiate_adapter(adapter_id: str) -> HandshakeResult:
+    root = runtime_root()
+    runtime = load_manifest(root / "runtime" / "manifest.json")
+    adapter = load_manifest(root / "runtime" / "manifests" / f"{adapter_id}.json")
+    if not isinstance(runtime, RuntimeManifest) or not isinstance(adapter, AdapterManifest):
+        raise ValueError("runtime or adapter manifest has an invalid shape")
+    return negotiate(runtime, adapter)
+
+
+def require_adapter(adapter_id: str) -> HandshakeResult:
+    result = negotiate_adapter(adapter_id)
+    if not result.accepted:
+        raise RuntimeError(f"DCC_MCP_RUNTIME_HANDSHAKE_FAILED:{result.reason}")
+    return result

dcc_mcp_runtime/cli.py

@@ -0,0 +1,25 @@
+"""Small validation CLI used by installers and CI."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from .manifest import load_manifest
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="dcc-mcp-runtime")
+    sub = parser.add_subparsers(dest="command", required=True)
+    validate = sub.add_parser("validate-manifest")
+    validate.add_argument("path")
+    args = parser.parse_args()
+    if args.command == "validate-manifest":
+        manifest = load_manifest(args.path)
+        print(json.dumps(manifest.to_dict(), ensure_ascii=False, indent=2))
+        return 0
+    return 2
+
+
+if __name__ == "__main__":  # pragma: no cover - exercised by the CLI smoke path
+    raise SystemExit(main())

dcc_mcp_runtime/handshake.py

@@ -0,0 +1,55 @@
+"""Runtime/adapter capability negotiation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .manifest import AdapterManifest, RuntimeManifest
+
+
+@dataclass(frozen=True)
+class CapabilityHandshake:
+    runtime_id: str
+    runtime_version: str
+    python_abi: str
+    dcc_mcp_core: str
+    adapter_id: str
+    adapter_version: str
+    capabilities: tuple[str, ...]
+    capabilities_fingerprint: str
+
+
+@dataclass(frozen=True)
+class HandshakeResult:
+    accepted: bool
+    reason: str
+    handshake: CapabilityHandshake | None = None
+
+
+def negotiate(runtime: RuntimeManifest, adapter: AdapterManifest) -> HandshakeResult:
+    if adapter.host_mode == "embedded":
+        return HandshakeResult(False, "embedded_adapter_requires_host_runtime")
+    if runtime.python_abi != adapter.python_abi:
+        return HandshakeResult(False, "python_abi_mismatch")
+    if runtime.dcc_mcp_core != adapter.dcc_mcp_core:
+        return HandshakeResult(False, "dcc_mcp_core_mismatch")
+    capabilities = tuple(sorted(set(adapter.capabilities)))
+    # The runtime does not sign/authorise capabilities; it carries a stable
+    # handshake value for the gateway to compare with its catalog.
+    import hashlib
+
+    fingerprint = hashlib.sha256("\n".join(capabilities).encode()).hexdigest()
+    return HandshakeResult(
+        True,
+        "accepted",
+        CapabilityHandshake(
+            runtime.runtime_id,
+            runtime.version,
+            runtime.python_abi,
+            runtime.dcc_mcp_core,
+            adapter.adapter_id,
+            adapter.version,
+            capabilities,
+            fingerprint,
+        ),
+    )

dcc_mcp_runtime/lifecycle.py

@@ -0,0 +1,51 @@
+"""Consent-gated, verifiable and rollback-safe install planning."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class InstallPlan:
+    operation_id: str
+    runtime_id: str
+    target_version: str
+    package_path: str
+    expected_sha256: str
+    previous_version: str | None
+    requires_confirmation: bool = True
+    rollback_version: str | None = None
+
+
+@dataclass(frozen=True)
+class InstallResult:
+    operation_id: str
+    status: str
+    active_version: str | None
+    reason: str
+
+
+def plan_install(
+    *,
+    operation_id: str,
+    runtime_id: str,
+    target_version: str,
+    package_path: str,
+    expected_sha256: str,
+    previous_version: str | None = None,
+) -> InstallPlan:
+    """Return an exact plan; execution belongs to a host-owned allow-list."""
+    if not operation_id or not runtime_id or not target_version or not package_path:
+        raise ValueError("operation_id, runtime_id, target_version and package_path are required")
+    if len(expected_sha256) != 64:
+        raise ValueError("expected_sha256 must be a 64-character SHA-256 hex digest")
+    return InstallPlan(
+        operation_id,
+        runtime_id,
+        target_version,
+        package_path,
+        expected_sha256,
+        previous_version,
+        True,
+        previous_version,
+    )

dcc_mcp_runtime/manifest.py

@@ -0,0 +1,111 @@
+"""Strict, serialisable runtime and adapter manifests.
+
+The manifest is deliberately data-only so it can be verified before importing
+any adapter code. Hash/signature fields are opaque strings; signature checking
+is delegated to the operator-owned trust service.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+SCHEMA_VERSION = "1"
+
+
+@dataclass(frozen=True)
+class AdapterManifest:
+    adapter_id: str
+    version: str
+    dcc_mcp_core: str
+    python_abi: str
+    capabilities: tuple[str, ...]
+    wheel_sha256: str
+    signature: str | None = None
+    host_mode: str = "external"
+
+    def __post_init__(self) -> None:
+        if not self.adapter_id or not self.version or not self.python_abi:
+            raise ValueError("adapter_id, version and python_abi are required")
+        if self.host_mode not in {"external", "embedded"}:
+            raise ValueError("host_mode must be external or embedded")
+        if len(self.wheel_sha256) != 64:
+            raise ValueError("wheel_sha256 must be a 64-character SHA-256 hex digest")
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> AdapterManifest:
+        return cls(
+            adapter_id=str(data["adapter_id"]),
+            version=str(data["version"]),
+            dcc_mcp_core=str(data["dcc_mcp_core"]),
+            python_abi=str(data["python_abi"]),
+            capabilities=tuple(str(x) for x in data.get("capabilities", [])),
+            wheel_sha256=str(data["wheel_sha256"]),
+            signature=data.get("signature"),
+            host_mode=str(data.get("host_mode", "external")),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "adapter_id": self.adapter_id,
+            "version": self.version,
+            "dcc_mcp_core": self.dcc_mcp_core,
+            "python_abi": self.python_abi,
+            "capabilities": list(self.capabilities),
+            "wheel_sha256": self.wheel_sha256,
+            "signature": self.signature,
+            "host_mode": self.host_mode,
+        }
+
+
+@dataclass(frozen=True)
+class RuntimeManifest:
+    runtime_id: str
+    version: str
+    python_version: str
+    python_abi: str
+    platform: str
+    dcc_mcp_core: str
+    adapters: tuple[AdapterManifest, ...] = field(default_factory=tuple)
+    runtime_sha256: str | None = None
+    signature: str | None = None
+    schema_version: str = SCHEMA_VERSION
+
+    def __post_init__(self) -> None:
+        if self.schema_version != SCHEMA_VERSION:
+            raise ValueError(f"unsupported manifest schema: {self.schema_version}")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": self.schema_version,
+            "runtime_id": self.runtime_id,
+            "version": self.version,
+            "python_version": self.python_version,
+            "python_abi": self.python_abi,
+            "platform": self.platform,
+            "dcc_mcp_core": self.dcc_mcp_core,
+            "runtime_sha256": self.runtime_sha256,
+            "signature": self.signature,
+            "adapters": [a.to_dict() for a in self.adapters],
+        }
+
+
+def load_manifest(path: str | Path) -> RuntimeManifest | AdapterManifest:
+    """Load and validate either manifest shape without importing adapters."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if "runtime_id" in data:
+        return RuntimeManifest(
+            runtime_id=str(data["runtime_id"]),
+            version=str(data["version"]),
+            python_version=str(data["python_version"]),
+            python_abi=str(data["python_abi"]),
+            platform=str(data["platform"]),
+            dcc_mcp_core=str(data["dcc_mcp_core"]),
+            adapters=tuple(AdapterManifest.from_dict(x) for x in data.get("adapters", [])),
+            runtime_sha256=data.get("runtime_sha256"),
+            signature=data.get("signature"),
+            schema_version=str(data.get("schema_version", SCHEMA_VERSION)),
+        )
+    return AdapterManifest.from_dict(data)

dcc_mcp_runtime-0.2.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.5
+Name: dcc-mcp-runtime
+Version: 0.2.0
+Summary: Shared, signed runtime contract for external DCC-MCP adapters
+Author-email: loonghao <hal.long@outlook.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == 'dev'
+Requires-Dist: pytest<9,>=8; extra == 'dev'
+Requires-Dist: ruff<1,>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dcc-mcp-runtime
+
+Shared Python runtime for **external** DCC-MCP adapters (Adobe, CapCut and OBS).
+The runtime is a versioned, side-by-side install containing CPython, `dcc-mcp-core`
+and adapter wheels under `lib/site-packages`. Development still uses `uv`/wheels;
+PyOxidizer is the reproducible distribution path.
+
+Embedded DCC Python (Maya, Blender, Houdini, 3ds Max, etc.) is intentionally not
+injected into this runtime. Those adapters keep their host interpreter and only
+consume the same protocol/manifest contract.
+
+## Quick start
+
+```powershell
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+python -m build
+```
+
+`runtime/manifest.json` is the machine-readable contract. Validate an adapter
+before loading it:
+
+```powershell
+python -m dcc_mcp_runtime.cli validate-manifest runtime/manifests/capcut.json
+```
+
+Installation and upgrade are represented by a typed plan. The runtime never
+executes arbitrary shell/Python: an operator must approve an exact plan and a
+host-owned installer performs the allow-listed operation. A failed health/hash
+verification leaves the previous runtime active for rollback.
+
+Releases use [release-please](https://github.com/googleapis/release-please):
+Conventional Commits on `main` create a release PR; merging it creates the tag
+and release, then the same workflow builds and uploads the wheel, sdist, and
+runtime/adapter manifests to that exact release tag.
+
+See [migration guides](docs/migration/) and [ADR 0001](docs/ADR-0001-shared-runtime.md).

dcc_mcp_runtime-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+dcc_mcp_runtime/__init__.py,sha256=8TL9PeGaEv4HKlPvJ4QO_7NabHO8rnweJnz_vwCTtsk,477
+dcc_mcp_runtime/bootstrap.py,sha256=dZ8QBUtCxD14g3IwURAs6I_WyvhSM4MogSZu5JYBQn0,1418
+dcc_mcp_runtime/cli.py,sha256=cHwybIJlQweOwrxL3tIWyudiyE0wuyfVKyfj1X5NH1U,723
+dcc_mcp_runtime/handshake.py,sha256=zk0UbIcjcP9cJZYeKApSbegi83Z7LNt7V-7QzMF9PIw,1642
+dcc_mcp_runtime/lifecycle.py,sha256=2ylj2RYkL-DbfWhDa9eaLk4zfLB0ucMKa1yQthoKjEw,1337
+dcc_mcp_runtime/manifest.py,sha256=A3SfmD9zNUMW6Tazt-b5absNalxIejP0ayTJFMPJzXI,4037
+dcc_mcp_runtime-0.2.0.dist-info/METADATA,sha256=l4UoKURlrYARmrNzvWHbuOzctZxTOhBovZRrSoCjxxQ,1924
+dcc_mcp_runtime-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+dcc_mcp_runtime-0.2.0.dist-info/entry_points.txt,sha256=cw8ApKaEmDXDgRf5AgfZPeIWJIEW7bOTGDpdG5V5ac4,61
+dcc_mcp_runtime-0.2.0.dist-info/licenses/LICENSE,sha256=k7pmNfphyrF9W_4TDwL3TTCuKDARdzrCHmhZT4yVMig,1065
+dcc_mcp_runtime-0.2.0.dist-info/RECORD,,

dcc_mcp_runtime-0.2.0.dist-info/WHEEL

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

dcc_mcp_runtime-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dcc-mcp-runtime = dcc_mcp_runtime.cli:main

dcc_mcp_runtime-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 loonghao
+
+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.