dcc-mcp-runtime 0.2.0__tar.gz

dcc_mcp_runtime-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.9", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install package and test dependencies
+        run: python -m pip install -e ".[dev]"
+      - name: Test
+        run: python -m pytest -q
+      - name: Lint
+        run: python -m ruff check src tests
+      - name: Format check
+        run: python -m ruff format --check src tests
+      - name: Validate manifests
+        shell: bash
+        run: |
+          python -m dcc_mcp_runtime.cli validate-manifest runtime/manifest.json
+          for f in runtime/manifests/*.json; do
+            python -m dcc_mcp_runtime.cli validate-manifest "$f" >/dev/null
+          done
+      - name: Build artifacts
+        run: python -m build

dcc_mcp_runtime-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,61 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+      version: ${{ steps.release.outputs.version }}
+    steps:
+      - id: release
+        uses: googleapis/release-please-action@v4
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  build-release:
+    needs: release-please
+    if: ${{ needs.release-please.outputs.release_created == 'true' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.release-please.outputs.tag_name }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install package and release tooling
+        run: python -m pip install -e ".[dev]"
+      - name: Test release commit
+        run: python -m pytest -q
+      - name: Lint release commit
+        run: python -m ruff check src tests
+      - name: Check formatting
+        run: python -m ruff format --check src tests
+      - name: Validate manifests
+        run: |
+          python -m dcc_mcp_runtime.cli validate-manifest runtime/manifest.json
+          for f in runtime/manifests/*.json; do python -m dcc_mcp_runtime.cli validate-manifest "$f" >/dev/null; done
+      - name: Build release artifacts
+        run: python -m build
+      - name: Upload release artifacts
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.release-please.outputs.tag_name }}
+          files: |
+            dist/*
+            runtime/manifest.json
+            runtime/manifests/*.json
+            docs/migration/*.md

dcc_mcp_runtime-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/

dcc_mcp_runtime-0.2.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.2.0"
+}

dcc_mcp_runtime-0.2.0/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-runtime/compare/v0.1.0...v0.2.0) (2026-09-12)
+
+
+### Features
+
+* route OBS through shared runtime ([42dc3e7](https://github.com/dcc-mcp/dcc-mcp-runtime/commit/42dc3e7950309280edc215662d5793601f68de87))
+
+## 0.1.0
+
+- Initial shared external-adapter runtime contract.
+- Added manifest validation, capability handshake, install-plan lifecycle, and
+  PyOxidizer packaging scaffold.
+- Added migration entrypoints for Adobe, CapCut, and OBS.
+
+This first release is a prerelease scaffold. Runtime and adapter signatures,
+wheel hashes, and final PyOxidizer binaries must be populated before a stable
+production release.

dcc_mcp_runtime-0.2.0/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.

dcc_mcp_runtime-0.2.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,38 @@
+# 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/adapters/adobe_runtime_entry.py

@@ -0,0 +1,18 @@
+"""Standalone Adobe/After Effects bridge entry point.
+
+The selected standalone DCC-MCP adapter is ``dcc-mcp-aftereffects``. The
+``adobepy`` repository remains an SDK/broker and is not launched here.
+"""
+
+from dcc_mcp_runtime.bootstrap import require_adapter
+
+
+def main() -> None:
+    require_adapter("adobe")
+    from dcc_mcp_aftereffects.server import start_server
+
+    start_server()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_runtime-0.2.0/adapters/aftereffects-runtime-handshake.patch

@@ -0,0 +1,12 @@
+diff --git a/src/dcc_mcp_aftereffects/server.py b/src/dcc_mcp_aftereffects/server.py
+--- a/src/dcc_mcp_aftereffects/server.py
++++ b/src/dcc_mcp_aftereffects/server.py
+@@
+ from dcc_mcp_core.server_base import DccServerBase
++from dcc_mcp_runtime.bootstrap import require_adapter
+@@
+ def start_server(port: Optional[int] = None) -> AfterEffectsMcpServer:
+     global _server
+     if _server is None or not _server.is_running:
++        require_adapter("adobe")
+         _server = AfterEffectsMcpServer(

dcc_mcp_runtime-0.2.0/adapters/capcut-runtime-handshake.patch

@@ -0,0 +1,12 @@
+diff --git a/src/dcc_mcp_capcut/server.py b/src/dcc_mcp_capcut/server.py
+--- a/src/dcc_mcp_capcut/server.py
++++ b/src/dcc_mcp_capcut/server.py
+@@
+ from dcc_mcp_core.server_base import DccServerBase
++from dcc_mcp_runtime.bootstrap import require_adapter
+@@
+ def start_server(port: Optional[int] = None) -> CapCutMcpServer:
+     global _server
+     if _server is None or not _server.is_running:
++        require_adapter("capcut")
+         _server = CapCutMcpServer(port if port is not None else DEFAULT_PORT)

dcc_mcp_runtime-0.2.0/adapters/capcut_runtime_entry.py

@@ -0,0 +1,14 @@
+"""Drop-in entry point for dcc-mcp-capcut in the shared runtime."""
+
+from dcc_mcp_runtime.bootstrap import require_adapter
+
+
+def main() -> None:
+    require_adapter("capcut")
+    from dcc_mcp_capcut.server import start_server
+
+    start_server()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_runtime-0.2.0/adapters/obs-runtime-handshake.patch

@@ -0,0 +1,12 @@
+diff --git a/src/dcc_mcp_obs/server.py b/src/dcc_mcp_obs/server.py
+--- a/src/dcc_mcp_obs/server.py
++++ b/src/dcc_mcp_obs/server.py
+@@
+ from dcc_mcp_core.server_base import DccServerBase
++from dcc_mcp_runtime.bootstrap import require_adapter
+@@
+ def start_server(*, port: int | None = None, host_pid: int | None = None) -> ObsMcpServer:
+     global _server
+     if _server is None or not _server.is_running:
++        require_adapter("obs")
+         if _server is not None:

dcc_mcp_runtime-0.2.0/adapters/obs_runtime_entry.py

@@ -0,0 +1,16 @@
+"""Drop-in entry point for dcc-mcp-obs in the shared runtime."""
+
+from dcc_mcp_runtime.bootstrap import require_adapter
+
+
+def main() -> None:
+    require_adapter("obs")
+    # The shared runtime owns Python and transport; OBS owns its native plugin
+    # and WebSocket bridge. Avoid the legacy self-contained wrapper.
+    from dcc_mcp_obs.server import main as obs_main
+
+    obs_main()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_runtime-0.2.0/docs/ADR-0001-shared-runtime.md

@@ -0,0 +1,24 @@
+# ADR 0001: Shared runtime for external DCC adapters
+
+## Decision
+
+Adobe, CapCut and OBS use a side-by-side PyOxidizer runtime containing a
+supported CPython build, `dcc-mcp-core`, and independently versioned adapter
+wheels in `lib/site-packages`. Adapter startup performs a manifest/ABI/
+capability handshake before registering with the gateway.
+
+Maya, Blender, Houdini, 3ds Max and other embedded hosts retain their native
+Python. They may consume the manifest protocol, but are never forced to load a
+foreign interpreter or ABI.
+
+## Integrity and lifecycle
+
+Every runtime and wheel records SHA-256 and an operator-issued signature. The
+installer receives an exact typed plan, requires explicit confirmation, verifies
+the downloaded artifact before activation, and keeps the previous side-by-side
+version until health and capability checks pass. Failed activation restores the
+previous version. The runtime has no generic shell, registry, or raw Python
+execution API.
+
+PyOxidizer is a publishing mechanism; `uv sync`, wheel builds and normal Python
+tests remain the development path.

dcc_mcp_runtime-0.2.0/docs/migration/adobe.md

@@ -0,0 +1,18 @@
+# Adobe migration
+
+## Selected standalone adapter
+
+The current standalone DCC-MCP bridge is `F:\github\dcc-mcp-aftereffects`: it
+contains `DccServerBase`, a CEP bridge broker and MCP server lifecycle. The
+`F:\github\dcc-mcp-adobepy` repository is an Adobe SDK/broker and remains a
+library/transport dependency; it is not treated as the standalone adapter.
+
+Keep the existing Photoshop/After Effects bridge and host plug-in in Adobe's
+native process. Replace only the standalone service launch with the shared
+runtime executable and pass the adapter wheel through the operator-owned
+`adapter_wheels` allow-list. Do not import the runtime into CEP/UXP or inject
+CPython into an Adobe process.
+
+At startup load `runtime/manifests/adobe.json`, call `negotiate`, then register
+the resulting `capabilities_fingerprint`. A failed ABI/core/signature check is
+reported as not-ready and leaves the previous runtime active.

dcc_mcp_runtime-0.2.0/docs/migration/capcut.md

@@ -0,0 +1,11 @@
+# CapCut migration
+
+CapCut is an external bridge: package `dcc-mcp-capcut` as a wheel and install it
+under `lib/site-packages` of the shared runtime. Keep CapCut Desktop UI control,
+token bridge and installation lifecycle in the adapter. The runtime only owns
+process startup, MCP/gateway registration and typed handshake.
+
+Use the exact install plan from `dcc_mcp_runtime.lifecycle.plan_install`; route
+execution through `ui_control__system_operation` with an operator grant. Never
+add a PowerShell or arbitrary Python fallback. Preserve side-by-side rollback
+when CapCut or the runtime fails readiness.

dcc_mcp_runtime-0.2.0/docs/migration/obs.md

@@ -0,0 +1,11 @@
+# OBS migration
+
+OBS is an external native/WebSocket bridge. Build `dcc-mcp-obs` as a wheel and
+place it in the runtime's `lib/site-packages`; start `adapters/obs_runtime_entry.py`
+from the shared runtime. Keep OBS process discovery, WebSocket authentication
+and scene operations in that adapter. Do not load the shared runtime into OBS's
+own plug-in Python.
+
+Use the existing OBS acceptance and readiness checks after handshake. Upgrade
+only after wheel hash/signature verification and a successful loopback health
+probe; retain the previous runtime for rollback.

dcc_mcp_runtime-0.2.0/pyoxidizer.bzl

@@ -0,0 +1,39 @@
+"""PyOxidizer distribution for the shared external-adapter runtime.
+
+Build with `pyoxidizer build --var core_version=0.20.14`. Adapter wheels are
+provided through the `DCC_MCP_RUNTIME_ADAPTER_WHEELS` build variable (a
+semicolon-separated, operator-supplied allow-list). No network or arbitrary
+commands are executed by this file.
+"""
+
+def make_exe():
+    dist = default_python_distribution()
+    policy = dist.make_python_packaging_policy()
+    policy.resources_location = "filesystem-relative:lib"
+    python_config = dist.make_python_interpreter_config()
+    python_config.oxidized_importer = False
+    python_config.filesystem_importer = True
+    python_config.module_search_paths = ["$ORIGIN/lib/site-packages"]
+    python_config.run_module = "dcc_mcp_runtime.cli"
+    python_config.parse_argv = True
+    exe = dist.to_python_executable(
+        name="dcc-mcp-runtime",
+        packaging_policy=policy,
+        config=python_config,
+    )
+    wheels = VARS.get("adapter_wheels", "").split(";")
+    wheels = [wheel for wheel in wheels if wheel]
+    resources = exe.pip_install([".", "dcc-mcp-core=={}".format(VARS["core_version"])])
+    if wheels:
+        resources += exe.pip_install(wheels)
+    exe.add_python_resources(resources)
+    return exe
+
+def make_install(exe):
+    files = FileManifest()
+    files.add_python_resource(".", exe)
+    return files
+
+register_target("exe", make_exe)
+register_target("install", make_install, depends=["exe"], default=True)
+resolve_targets()

dcc_mcp_runtime-0.2.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.26,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dcc-mcp-runtime"
+version = "0.2.0"
+description = "Shared, signed runtime contract for external DCC-MCP adapters"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "loonghao", email = "hal.long@outlook.com" }]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["build>=1.2,<2", "pytest>=8,<9", "ruff>=0.8,<1"]
+
+[project.scripts]
+dcc-mcp-runtime = "dcc_mcp_runtime.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_runtime"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+src = ["src", "tests"]
+exclude = ["build", "dist", ".venv", ".pytest_cache", ".ruff_cache"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]

dcc_mcp_runtime-0.2.0/release-please-config.json

@@ -0,0 +1,17 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "python",
+      "package-name": "dcc-mcp-runtime",
+      "changelog-path": "CHANGELOG.md",
+      "include-component-in-tag": false,
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "pyproject.toml",
+          "jsonpath": "$.project.version"
+        }
+      ]
+    }
+  }
+}

dcc_mcp_runtime-0.2.0/runtime/manifest.json

@@ -0,0 +1,12 @@
+{
+  "schema_version": "1",
+  "runtime_id": "dcc-mcp-external",
+  "version": "0.1.0",
+  "python_version": "3.11",
+  "python_abi": "cp311-win_amd64",
+  "platform": "windows-x86_64",
+  "dcc_mcp_core": ">=0.19.13,<1.0.0",
+  "runtime_sha256": null,
+  "signature": null,
+  "adapters": []
+}

dcc_mcp_runtime-0.2.0/runtime/manifests/adobe.json

@@ -0,0 +1,11 @@
+{
+  "schema_version": "1",
+  "adapter_id": "adobe",
+  "version": "0.1.0",
+  "dcc_mcp_core": ">=0.19.13,<1.0.0",
+  "python_abi": "cp311-win_amd64",
+  "capabilities": ["documents", "layers", "timeline", "media", "export"],
+  "wheel_sha256": "0000000000000000000000000000000000000000000000000000000000000000",
+  "signature": null,
+  "host_mode": "external"
+}

dcc_mcp_runtime-0.2.0/runtime/manifests/capcut.json

@@ -0,0 +1,11 @@
+{
+  "schema_version": "1",
+  "adapter_id": "capcut",
+  "version": "0.1.0",
+  "dcc_mcp_core": ">=0.19.13,<1.0.0",
+  "python_abi": "cp311-win_amd64",
+  "capabilities": ["project", "media", "timeline", "captions", "audio", "effects", "export"],
+  "wheel_sha256": "0000000000000000000000000000000000000000000000000000000000000000",
+  "signature": null,
+  "host_mode": "external"
+}

dcc_mcp_runtime-0.2.0/runtime/manifests/obs.json

@@ -0,0 +1,11 @@
+{
+  "schema_version": "1",
+  "adapter_id": "obs",
+  "version": "1.4.0",
+  "dcc_mcp_core": ">=0.19.13,<1.0.0",
+  "python_abi": "cp311-win_amd64",
+  "capabilities": ["scenes", "sources", "streaming", "recording", "replay-buffer"],
+  "wheel_sha256": "0000000000000000000000000000000000000000000000000000000000000000",
+  "signature": null,
+  "host_mode": "external"
+}

dcc_mcp_runtime-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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/tests/test_bootstrap.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from dcc_mcp_runtime.bootstrap import negotiate_adapter, runtime_root
+
+
+def test_runtime_root_can_be_explicit(monkeypatch):
+    monkeypatch.setenv("DCC_MCP_RUNTIME_ROOT", str(Path.cwd()))
+    assert runtime_root() == Path.cwd().resolve()
+
+
+def test_capcut_and_obs_compatibility_entries_handshake(monkeypatch):
+    monkeypatch.setenv("DCC_MCP_RUNTIME_ROOT", str(Path.cwd()))
+    assert negotiate_adapter("capcut").accepted
+    assert negotiate_adapter("obs").accepted

dcc_mcp_runtime-0.2.0/tests/test_runtime.py

@@ -0,0 +1,59 @@
+from dcc_mcp_runtime.handshake import negotiate
+from dcc_mcp_runtime.lifecycle import plan_install
+from dcc_mcp_runtime.manifest import AdapterManifest, RuntimeManifest, load_manifest
+
+HASH = "a" * 64
+
+
+def runtime() -> RuntimeManifest:
+    return RuntimeManifest(
+        runtime_id="test-runtime",
+        version="1.0.0",
+        python_version="3.11",
+        python_abi="cp311-win_amd64",
+        platform="windows-x86_64",
+        dcc_mcp_core=">=0.19.13,<1.0.0",
+    )
+
+
+def adapter(**overrides) -> AdapterManifest:
+    values = dict(
+        adapter_id="capcut",
+        version="0.1.0",
+        dcc_mcp_core=">=0.19.13,<1.0.0",
+        python_abi="cp311-win_amd64",
+        capabilities=("timeline", "media"),
+        wheel_sha256=HASH,
+    )
+    values.update(overrides)
+    return AdapterManifest(**values)
+
+
+def test_external_handshake_includes_stable_fingerprint():
+    result = negotiate(runtime(), adapter())
+    assert result.accepted is True
+    assert result.handshake is not None
+    assert len(result.handshake.capabilities_fingerprint) == 64
+
+
+def test_embedded_adapter_is_not_injected():
+    result = negotiate(runtime(), adapter(host_mode="embedded"))
+    assert result == result.__class__(False, "embedded_adapter_requires_host_runtime")
+
+
+def test_install_plan_requires_confirmation_and_rollback():
+    plan = plan_install(
+        operation_id="op-1",
+        runtime_id="dcc-mcp-external",
+        target_version="0.2.0",
+        package_path="runtime-0.2.0.zip",
+        expected_sha256=HASH,
+        previous_version="0.1.0",
+    )
+    assert plan.requires_confirmation
+    assert plan.rollback_version == "0.1.0"
+
+
+def test_runtime_manifest_is_loadable():
+    manifest = load_manifest("runtime/manifest.json")
+    assert manifest.runtime_id == "dcc-mcp-external"