dcc-mcp-renderdoc 0.2.0__tar.gz

dcc_mcp_renderdoc-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+.renderdoc-bin/
+artifacts/
+dist/
+build/
+*.egg-info/
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+tests/renderdoc_smoke
+tests/renderdoc_smoke.exe
+

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

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

dcc_mcp_renderdoc-0.2.0/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.1.0...v0.2.0) (2026-07-15)
+
+
+### Features
+
+* add RenderDoc MCP adapter ([a324344](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/a324344d5dcab758282c77598f4591076526f44e))
+
+
+### Bug Fixes
+
+* capture a supported OpenGL core context ([7817a6f](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/7817a6fd3a7e683a37348ed4a0582bfe456024b6))
+* include C boolean definitions in smoke target ([a9471ed](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/a9471ed7fef6f663a74ed9c9207ae8231bc5dafc))
+* initialize OpenGL before frame capture ([af3c93c](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/af3c93c2b7fc794769187d7e237596d5c37de97b))
+* target explicit RenderDoc frame capture ([99f1568](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/99f1568e0367c156c6c01106109ea4333e0788f5))
+* trigger a presented frame in RenderDoc smoke ([2d939cb](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/2d939cb3432ff6280ac44e56b6f785d1ff98d2ee))
+
+## Changelog
+
+All notable changes to this project will be documented in this file.

dcc_mcp_renderdoc-0.2.0/LICENSE

@@ -0,0 +1,22 @@
+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_renderdoc-0.2.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: dcc-mcp-renderdoc
+Version: 0.2.0
+Summary: RenderDoc capture and replay automation skills for DCC-MCP
+Project-URL: Homepage, https://github.com/dcc-mcp/dcc-mcp-renderdoc
+Project-URL: Repository, https://github.com/dcc-mcp/dcc-mcp-renderdoc
+Project-URL: Issues, https://github.com/dcc-mcp/dcc-mcp-renderdoc/issues
+Author-email: loonghao <hal.long@outlook.com>
+License: MIT
+License-File: LICENSE
+Keywords: automation,game-development,graphics-debugging,mcp,renderdoc
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.9
+Requires-Dist: dcc-mcp-core<1.0.0,>=0.19.38
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dcc-mcp-renderdoc
+
+RenderDoc capture and replay automation for the DCC Model Context Protocol ecosystem.
+
+The adapter is headless-first: it reuses the official `renderdoccmd` executable for capture and
+conversion, so agents can automate graphics regression triage without keeping the RenderDoc GUI
+open or installing a second bridge.
+
+## Install
+
+```bash
+pip install dcc-mcp-renderdoc
+```
+
+Install RenderDoc separately, then expose its command line tool with either `PATH` or:
+
+```bash
+export DCC_MCP_RENDERDOC_CMD=/opt/renderdoc/bin/renderdoccmd
+dcc-mcp-renderdoc
+```
+
+On Windows, set the variable to `renderdoccmd.exe`.
+
+## Agent workflows
+
+- Launch a game or test executable under RenderDoc and wait for a typed `.rdc` capture.
+- Inspect capture driver, machine identity, chunk version, API-call counts, and representative calls.
+- Export a capture thumbnail for visual review.
+- Export Chrome trace JSON for timeline tooling.
+
+The capture tool launches only the explicit executable and arguments supplied by the caller. It
+never invokes a shell. Analysis tools are read-only with respect to the `.rdc` input.
+
+## Real CI
+
+CI discovers the current stable RenderDoc build from the official downloads page. It compiles a
+small OpenGL program, captures a real frame under Xvfb, calls the MCP analysis tool against the
+resulting `.rdc`, and verifies thumbnail and timeline exports.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run python -m pytest
+uv run ruff check src tests tools
+uv run python tools/lint_skills.py
+```
+
+RenderDoc is an MIT-licensed graphics debugger maintained independently at
+[renderdoc.org](https://renderdoc.org/). This adapter is not affiliated with the RenderDoc project.
+

dcc_mcp_renderdoc-0.2.0/README.md

@@ -0,0 +1,51 @@
+# dcc-mcp-renderdoc
+
+RenderDoc capture and replay automation for the DCC Model Context Protocol ecosystem.
+
+The adapter is headless-first: it reuses the official `renderdoccmd` executable for capture and
+conversion, so agents can automate graphics regression triage without keeping the RenderDoc GUI
+open or installing a second bridge.
+
+## Install
+
+```bash
+pip install dcc-mcp-renderdoc
+```
+
+Install RenderDoc separately, then expose its command line tool with either `PATH` or:
+
+```bash
+export DCC_MCP_RENDERDOC_CMD=/opt/renderdoc/bin/renderdoccmd
+dcc-mcp-renderdoc
+```
+
+On Windows, set the variable to `renderdoccmd.exe`.
+
+## Agent workflows
+
+- Launch a game or test executable under RenderDoc and wait for a typed `.rdc` capture.
+- Inspect capture driver, machine identity, chunk version, API-call counts, and representative calls.
+- Export a capture thumbnail for visual review.
+- Export Chrome trace JSON for timeline tooling.
+
+The capture tool launches only the explicit executable and arguments supplied by the caller. It
+never invokes a shell. Analysis tools are read-only with respect to the `.rdc` input.
+
+## Real CI
+
+CI discovers the current stable RenderDoc build from the official downloads page. It compiles a
+small OpenGL program, captures a real frame under Xvfb, calls the MCP analysis tool against the
+resulting `.rdc`, and verifies thumbnail and timeline exports.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run python -m pytest
+uv run ruff check src tests tools
+uv run python tools/lint_skills.py
+```
+
+RenderDoc is an MIT-licensed graphics debugger maintained independently at
+[renderdoc.org](https://renderdoc.org/). This adapter is not affiliated with the RenderDoc project.
+

dcc_mcp_renderdoc-0.2.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dcc-mcp-renderdoc"
+version = "0.2.0"
+description = "RenderDoc capture and replay automation skills for DCC-MCP"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "loonghao", email = "hal.long@outlook.com" }]
+keywords = ["renderdoc", "mcp", "graphics-debugging", "game-development", "automation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Games/Entertainment",
+]
+dependencies = ["dcc-mcp-core>=0.19.38,<1.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/dcc-mcp/dcc-mcp-renderdoc"
+Repository = "https://github.com/dcc-mcp/dcc-mcp-renderdoc"
+Issues = "https://github.com/dcc-mcp/dcc-mcp-renderdoc/issues"
+
+[project.optional-dependencies]
+dev = ["build>=1.2", "pytest>=8", "ruff>=0.8", "twine>=6"]
+
+[project.scripts]
+dcc-mcp-renderdoc = "dcc_mcp_renderdoc.server:main"
+
+[project.entry-points."dcc_mcp.adapters"]
+renderdoc = "dcc_mcp_renderdoc:RenderDocMcpServer"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_renderdoc"]
+artifacts = ["src/dcc_mcp_renderdoc/skills/**"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/dcc_mcp_renderdoc",
+  "tests",
+  "tools",
+  "README.md",
+  "CHANGELOG.md",
+  "LICENSE",
+  "release-please-config.json",
+  ".release-please-manifest.json",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "."]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B"]
+
+[tool.ruff.lint.per-file-ignores]
+"src/dcc_mcp_renderdoc/skills/**/scripts/*.py" = ["E501"]

dcc_mcp_renderdoc-0.2.0/release-please-config.json

@@ -0,0 +1,2 @@
+{"packages":{".":{"release-type":"python","package-name":"dcc-mcp-renderdoc","changelog-path":"CHANGELOG.md","include-component-in-tag":false,"extra-files":[{"type":"toml","path":"pyproject.toml","jsonpath":"$.project.version"},{"type":"generic","path":"src/dcc_mcp_renderdoc/__version__.py"}]}}}
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/__init__.py

@@ -0,0 +1,6 @@
+"""RenderDoc adapter for DCC-MCP."""
+
+from .__version__ import __version__
+from .server import RenderDocMcpServer
+
+__all__ = ["RenderDocMcpServer", "__version__"]

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/__version__.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "0.1.0"

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/runtime.py

@@ -0,0 +1,255 @@
+"""Small, typed wrapper around RenderDoc's official command-line client."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tempfile
+import xml.etree.ElementTree as ET
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable, Optional, Sequence
+
+
+class RenderDocError(RuntimeError):
+    """Raised when a RenderDoc operation cannot satisfy its contract."""
+
+
+def resolve_renderdoccmd(explicit: Optional[str] = None) -> Path:
+    """Resolve an executable RenderDoc CLI without invoking a shell."""
+    candidate = explicit or os.environ.get("DCC_MCP_RENDERDOC_CMD")
+    if candidate:
+        path = Path(candidate).expanduser().resolve()
+        if path.is_file():
+            return path
+        raise RenderDocError(f"RenderDoc command does not exist: {path}")
+
+    for name in ("renderdoccmd.exe", "renderdoccmd"):
+        found = shutil.which(name)
+        if found:
+            return Path(found).resolve()
+    raise RenderDocError(
+        "renderdoccmd was not found; install RenderDoc or set DCC_MCP_RENDERDOC_CMD"
+    )
+
+
+def _run(
+    arguments: Sequence[str],
+    *,
+    timeout_secs: int,
+    command: Optional[str] = None,
+) -> subprocess.CompletedProcess[str]:
+    executable = resolve_renderdoccmd(command)
+    try:
+        result = subprocess.run(
+            [str(executable), *arguments],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout_secs,
+            shell=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise RenderDocError(f"RenderDoc command timed out after {timeout_secs}s") from exc
+    except OSError as exc:
+        raise RenderDocError(f"Could not start RenderDoc: {exc}") from exc
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "unknown error").strip()[-2000:]
+        raise RenderDocError(f"RenderDoc exited with code {result.returncode}: {detail}")
+    return result
+
+
+def get_version(*, command: Optional[str] = None) -> dict[str, Any]:
+    result = _run(["version"], timeout_secs=30, command=command)
+    output = "\n".join(part.strip() for part in (result.stdout, result.stderr) if part.strip())
+    return {"command": str(resolve_renderdoccmd(command)), "version_output": output}
+
+
+def capture_program(
+    executable: str,
+    output_template: str,
+    *,
+    arguments: Optional[Sequence[str]] = None,
+    working_directory: Optional[str] = None,
+    wait_for_exit: bool = True,
+    api_validation: bool = False,
+    hook_children: bool = False,
+    timeout_secs: int = 300,
+    command: Optional[str] = None,
+) -> dict[str, Any]:
+    """Launch one explicit executable under RenderDoc and return new captures."""
+    target = Path(executable).expanduser().resolve()
+    if not target.is_file():
+        raise RenderDocError(f"Target executable does not exist: {target}")
+    output = Path(output_template).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    cwd = Path(working_directory).expanduser().resolve() if working_directory else target.parent
+    if not cwd.is_dir():
+        raise RenderDocError(f"Working directory does not exist: {cwd}")
+
+    before = {path.resolve() for path in output.parent.glob("*.rdc")}
+    cli_args = ["capture", "--working-dir", str(cwd), "--capture-file", str(output)]
+    if wait_for_exit:
+        cli_args.append("--wait-for-exit")
+    if api_validation:
+        cli_args.append("--opt-api-validation")
+    if hook_children:
+        cli_args.append("--opt-hook-children")
+    cli_args.extend([str(target), *(str(value) for value in arguments or [])])
+    result = _run(cli_args, timeout_secs=timeout_secs, command=command)
+
+    captures = sorted(
+        (path.resolve() for path in output.parent.glob("*.rdc") if path.resolve() not in before),
+        key=lambda path: path.stat().st_mtime_ns,
+    )
+    if not captures:
+        output_detail = "\n".join(
+            part.strip() for part in (result.stdout, result.stderr) if part.strip()
+        )[-2000:]
+        raise RenderDocError(
+            "The target exited without creating a new .rdc capture; ensure it presents a frame "
+            f"or uses RenderDoc's in-application capture API. RenderDoc output: {output_detail}"
+        )
+    return {
+        "target": str(target),
+        "captures": [str(path) for path in captures],
+        "stdout": result.stdout.strip(),
+    }
+
+
+def _require_capture(capture_file: str) -> Path:
+    path = Path(capture_file).expanduser().resolve()
+    if not path.is_file() or path.suffix.lower() != ".rdc":
+        raise RenderDocError(f"RenderDoc capture does not exist or is not .rdc: {path}")
+    return path
+
+
+def _child_text(parent: ET.Element, name: str) -> Optional[str]:
+    child = parent.find(name)
+    return child.text.strip() if child is not None and child.text else None
+
+
+def parse_capture_xml(xml_file: str, *, representative_limit: int = 20) -> dict[str, Any]:
+    """Parse the stable high-level fields emitted by RenderDoc's XML converter."""
+    path = Path(xml_file)
+    try:
+        root = ET.parse(path).getroot()
+    except (ET.ParseError, OSError) as exc:
+        raise RenderDocError(f"Could not parse RenderDoc XML: {exc}") from exc
+    if root.tag != "rdc":
+        raise RenderDocError(f"Unexpected RenderDoc XML root: {root.tag}")
+    header = root.find("header")
+    chunks = root.find("chunks")
+    if header is None or chunks is None:
+        raise RenderDocError("RenderDoc XML is missing header or chunks")
+
+    driver = header.find("driver")
+    thumbnail = header.find("thumbnail")
+    names = [chunk.get("name") or "unnamed" for chunk in chunks.findall("chunk")]
+    counts = Counter(names)
+    return {
+        "driver": {
+            "id": driver.get("id") if driver is not None else None,
+            "name": driver.text.strip() if driver is not None and driver.text else None,
+        },
+        "machine_ident": _child_text(header, "machineIdent"),
+        "thumbnail": {
+            "width": int(thumbnail.get("width", "0")) if thumbnail is not None else 0,
+            "height": int(thumbnail.get("height", "0")) if thumbnail is not None else 0,
+        },
+        "chunk_version": chunks.get("version"),
+        "chunk_count": len(names),
+        "chunk_frequencies": [
+            {"name": name, "count": count} for name, count in counts.most_common(20)
+        ],
+        "representative_chunks": names[:representative_limit],
+    }
+
+
+def inspect_capture(
+    capture_file: str,
+    *,
+    representative_limit: int = 20,
+    command: Optional[str] = None,
+) -> dict[str, Any]:
+    capture = _require_capture(capture_file)
+    with tempfile.TemporaryDirectory(prefix="dcc-mcp-renderdoc-") as directory:
+        xml_file = Path(directory) / "capture.xml"
+        _run(
+            [
+                "convert",
+                "--filename",
+                str(capture),
+                "--output",
+                str(xml_file),
+                "--convert-format",
+                "xml",
+            ],
+            timeout_secs=180,
+            command=command,
+        )
+        details = parse_capture_xml(str(xml_file), representative_limit=representative_limit)
+    return {"capture_file": str(capture), "size_bytes": capture.stat().st_size, **details}
+
+
+def _prepare_output(output_file: str, expected_suffixes: Iterable[str]) -> Path:
+    path = Path(output_file).expanduser().resolve()
+    if path.suffix.lower() not in set(expected_suffixes):
+        choices = ", ".join(sorted(expected_suffixes))
+        raise RenderDocError(f"Output must use one of these extensions: {choices}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def export_thumbnail(
+    capture_file: str,
+    output_file: str,
+    *,
+    max_size: int = 0,
+    command: Optional[str] = None,
+) -> dict[str, Any]:
+    capture = _require_capture(capture_file)
+    output = _prepare_output(output_file, {".bmp", ".jpg", ".png", ".tga"})
+    _run(
+        ["thumb", "--out", str(output), "--max-size", str(max_size), str(capture)],
+        timeout_secs=120,
+        command=command,
+    )
+    if not output.is_file():
+        raise RenderDocError("RenderDoc reported success but did not create the thumbnail")
+    return {
+        "capture_file": str(capture),
+        "output_file": str(output),
+        "size_bytes": output.stat().st_size,
+    }
+
+
+def export_timeline(
+    capture_file: str,
+    output_file: str,
+    *,
+    command: Optional[str] = None,
+) -> dict[str, Any]:
+    capture = _require_capture(capture_file)
+    output = _prepare_output(output_file, {".json"})
+    _run(
+        [
+            "convert",
+            "--filename",
+            str(capture),
+            "--output",
+            str(output),
+            "--convert-format",
+            "chrome.json",
+        ],
+        timeout_secs=180,
+        command=command,
+    )
+    if not output.is_file():
+        raise RenderDocError("RenderDoc reported success but did not create the timeline")
+    return {
+        "capture_file": str(capture),
+        "output_file": str(output),
+        "size_bytes": output.stat().st_size,
+    }

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/server.py

@@ -0,0 +1,78 @@
+"""Standalone RenderDoc MCP server lifecycle."""
+
+from __future__ import annotations
+
+import os
+import signal
+import sys
+import threading
+from pathlib import Path
+from typing import Optional
+
+from dcc_mcp_core import DccServerOptions
+from dcc_mcp_core.server_base import DccServerBase
+
+from .__version__ import __version__
+from .runtime import RenderDocError, get_version
+
+DEFAULT_PORT = 8765
+_server: Optional["RenderDocMcpServer"] = None
+
+
+class RenderDocMcpServer(DccServerBase):
+    """Headless DCC-MCP adapter backed by renderdoccmd."""
+
+    def __init__(self, port: int = DEFAULT_PORT) -> None:
+        os.environ.setdefault("DCC_MCP_PYTHON_EXECUTABLE", sys.executable)
+        options = DccServerOptions.from_env(
+            "renderdoc",
+            Path(__file__).resolve().parent / "skills",
+            port=port,
+            server_name="dcc-mcp-renderdoc",
+            server_version=__version__,
+        )
+        super().__init__(options=options)
+
+    def _version_string(self) -> str:
+        try:
+            return get_version()["version_output"]
+        except RenderDocError:
+            return "RenderDoc CLI unavailable"
+
+
+def start_server(port: Optional[int] = None) -> RenderDocMcpServer:
+    global _server
+    if _server is None or not _server.is_running:
+        selected_port = (
+            port
+            if port is not None
+            else int(os.environ.get("DCC_MCP_RENDERDOC_PORT", DEFAULT_PORT))
+        )
+        _server = RenderDocMcpServer(selected_port)
+        _server.register_builtin_actions()
+        _server.start()
+    return _server
+
+
+def stop_server() -> None:
+    global _server
+    if _server is not None:
+        _server.stop()
+        _server = None
+
+
+def main() -> None:
+    """Run until interrupted."""
+    stopped = threading.Event()
+    signal.signal(signal.SIGINT, lambda *_: stopped.set())
+    if hasattr(signal, "SIGTERM"):
+        signal.signal(signal.SIGTERM, lambda *_: stopped.set())
+    start_server()
+    try:
+        stopped.wait()
+    finally:
+        stop_server()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: renderdoc-analysis
+description: >-
+  Domain skill — Inspect an existing RenderDoc capture and export its embedded thumbnail or Chrome
+  trace. Use for offline graphics triage and automation artifacts. Not for launching a capture —
+  use renderdoc-capture.
+license: MIT
+compatibility: "RenderDoc 1.45+; dcc-mcp-core 0.19+"
+allowed-tools: "python"
+metadata:
+  dcc-mcp:
+    dcc: renderdoc
+    layer: domain
+    version: "0.1.0"
+    search-hint: "RenderDoc inspect rdc chunks thumbnail Chrome trace graphics analysis"
+    tags: "renderdoc,analysis,thumbnail,timeline,graphics-debugging"
+    tools: tools.yaml
+    depends: "dcc-diagnostics"
+---
+
+# RenderDoc Analysis
+
+Inspect before exporting. These tools never modify the input `.rdc`; exports require an explicit
+destination path and create its parent directory when needed.
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/metadata/depends.md

@@ -0,0 +1,2 @@
+- dcc-diagnostics
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/export_thumbnail.py

@@ -0,0 +1,15 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import export_thumbnail
+
+
+@skill_entry
+def main(capture_file: str, output_file: str, max_size: int = 0, **_kwargs):
+    result = export_thumbnail(capture_file, output_file, max_size=max_size)
+    return skill_success("RenderDoc thumbnail exported.", **result)
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/export_timeline.py

@@ -0,0 +1,15 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import export_timeline
+
+
+@skill_entry
+def main(capture_file: str, output_file: str, **_kwargs):
+    result = export_timeline(capture_file, output_file)
+    return skill_success("RenderDoc Chrome timeline exported.", **result)
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/inspect_capture.py

@@ -0,0 +1,15 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import inspect_capture
+
+
+@skill_entry
+def main(capture_file: str, representative_limit: int = 20, **_kwargs):
+    result = inspect_capture(capture_file, representative_limit=representative_limit)
+    return skill_success("RenderDoc capture inspected.", **result)
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-analysis/tools.yaml

@@ -0,0 +1,63 @@
+tools:
+  - name: inspect_capture
+    description: Convert one .rdc capture to temporary XML and summarize stable header and chunk metadata. Use for offline triage. Not for GPU performance conclusions or high-level drawcall reconstruction.
+    input_schema:
+      type: object
+      required: [capture_file]
+      properties:
+        capture_file: {type: string, minLength: 1, maxLength: 1000}
+        representative_limit: {type: integer, minimum: 0, maximum: 100, default: 20}
+      additionalProperties: false
+    output_schema: {type: object}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: async
+    affinity: any
+    timeout_hint_secs: 180
+    source_file: scripts/inspect_capture.py
+    next-tools:
+      on-success: [renderdoc_analysis__export_thumbnail, renderdoc_analysis__export_timeline]
+      on-failure: [renderdoc_capture__get_version, dcc_diagnostics__audit_log]
+  - name: export_thumbnail
+    description: Export the embedded capture thumbnail as PNG, JPG, BMP, or TGA. Use for visual review artifacts. Not for replaying or rendering arbitrary capture resources.
+    input_schema:
+      type: object
+      required: [capture_file, output_file]
+      properties:
+        capture_file: {type: string, minLength: 1, maxLength: 1000}
+        output_file: {type: string, minLength: 1, maxLength: 1000}
+        max_size: {type: integer, minimum: 0, maximum: 16384, default: 0}
+      additionalProperties: false
+    output_schema: {type: object}
+    read_only: false
+    destructive: false
+    idempotent: true
+    execution: async
+    affinity: any
+    timeout_hint_secs: 120
+    source_file: scripts/export_thumbnail.py
+    next-tools:
+      on-success: [renderdoc_analysis__inspect_capture]
+      on-failure: [renderdoc_capture__get_version, dcc_diagnostics__audit_log]
+  - name: export_timeline
+    description: Export capture events as Chrome profiler JSON. Use for timeline tooling and CI artifacts. Not for authoritative GPU duration measurement.
+    input_schema:
+      type: object
+      required: [capture_file, output_file]
+      properties:
+        capture_file: {type: string, minLength: 1, maxLength: 1000}
+        output_file: {type: string, minLength: 1, maxLength: 1000}
+      additionalProperties: false
+    output_schema: {type: object}
+    read_only: false
+    destructive: false
+    idempotent: true
+    execution: async
+    affinity: any
+    timeout_hint_secs: 180
+    source_file: scripts/export_timeline.py
+    next-tools:
+      on-success: [renderdoc_analysis__inspect_capture]
+      on-failure: [renderdoc_capture__get_version, dcc_diagnostics__audit_log]
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: renderdoc-capture
+description: >-
+  Domain skill — Discover RenderDoc and launch an explicit game or graphics executable under
+  capture. Use for repeatable local or CI frame capture. Not for reading an existing capture —
+  use renderdoc-analysis.
+license: MIT
+compatibility: "RenderDoc 1.45+; dcc-mcp-core 0.19+"
+allowed-tools: "python"
+metadata:
+  dcc-mcp:
+    dcc: renderdoc
+    layer: domain
+    version: "0.1.0"
+    search-hint: "RenderDoc capture launch executable game graphics frame rdc"
+    tags: "renderdoc,capture,graphics-debugging,game-development"
+    tools: tools.yaml
+    depends: "dcc-diagnostics"
+---
+
+# RenderDoc Capture
+
+Call `get_version` before capture. `capture_program` starts only the explicit executable and
+arguments, never a shell. The target must trigger a RenderDoc frame capture.
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/metadata/depends.md

@@ -0,0 +1,2 @@
+- dcc-diagnostics
+

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/capture_program.py

@@ -0,0 +1,34 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import capture_program
+
+
+@skill_entry
+def main(
+    executable: str,
+    output_template: str,
+    arguments=None,
+    working_directory=None,
+    wait_for_exit: bool = True,
+    api_validation: bool = False,
+    hook_children: bool = False,
+    timeout_secs: int = 300,
+    **_kwargs,
+):
+    result = capture_program(
+        executable,
+        output_template,
+        arguments=arguments,
+        working_directory=working_directory,
+        wait_for_exit=wait_for_exit,
+        api_validation=api_validation,
+        hook_children=hook_children,
+        timeout_secs=timeout_secs,
+    )
+    return skill_success(f"Created {len(result['captures'])} RenderDoc capture(s).", **result)
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/get_version.py

@@ -0,0 +1,14 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import get_version
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success("RenderDoc CLI is available.", **get_version())
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/tools.yaml

@@ -0,0 +1,45 @@
+tools:
+  - name: get_version
+    description: Resolve renderdoccmd and return its version output. Use before capture or analysis to verify the runtime. Not for capture-file inspection.
+    input_schema: {type: object, properties: {}, additionalProperties: false}
+    output_schema: {type: object}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/get_version.py
+    next-tools:
+      on-success: [renderdoc_capture__capture_program]
+      on-failure: [dcc_diagnostics__audit_log]
+  - name: capture_program
+    description: Launch one explicit executable under RenderDoc and return newly created .rdc files. Use for controlled game or graphics test capture. Not for shell commands or attaching to an existing process.
+    input_schema:
+      type: object
+      required: [executable, output_template]
+      properties:
+        executable: {type: string, minLength: 1, maxLength: 1000}
+        output_template: {type: string, minLength: 1, maxLength: 1000}
+        arguments:
+          type: array
+          maxItems: 100
+          items: {type: string, maxLength: 2000}
+        working_directory: {type: string, maxLength: 1000}
+        wait_for_exit: {type: boolean, default: true}
+        api_validation: {type: boolean, default: false}
+        hook_children: {type: boolean, default: false}
+        timeout_secs: {type: integer, minimum: 1, maximum: 3600, default: 300}
+      additionalProperties: false
+    output_schema: {type: object}
+    read_only: false
+    destructive: false
+    idempotent: false
+    execution: async
+    affinity: any
+    timeout_hint_secs: 3600
+    source_file: scripts/capture_program.py
+    next-tools:
+      on-success: [renderdoc_analysis__inspect_capture, renderdoc_analysis__export_thumbnail]
+      on-failure: [dcc_diagnostics__audit_log]
+

dcc_mcp_renderdoc-0.2.0/tests/live_renderdoc_smoke.py

@@ -0,0 +1,142 @@
+"""Capture and inspect one real OpenGL frame through the MCP endpoint."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from dcc_mcp_renderdoc.server import RenderDocMcpServer
+
+
+def _post(url: str, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+    payload: dict[str, Any] = {"jsonrpc": "2.0", "id": 1, "method": method}
+    if params is not None:
+        payload["params"] = params
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload).encode(),
+        headers={
+            "Accept": "application/json, text/event-stream",
+            "Content-Type": "application/json",
+        },
+    )
+    with urllib.request.urlopen(request, timeout=60) as response:
+        return json.loads(response.read())
+
+
+def _content(response: dict[str, Any]) -> dict[str, Any]:
+    if response.get("error") or response.get("result", {}).get("isError"):
+        raise RuntimeError(json.dumps(response, indent=2))
+    result = response.get("result", {})
+    structured = result.get("structuredContent")
+    if isinstance(structured, dict):
+        return structured
+    if result.get("content"):
+        return json.loads(result["content"][0]["text"])
+    return result
+
+
+def _call(url: str, name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
+    return _content(_post(url, "tools/call", {"name": name, "arguments": arguments or {}}))
+
+
+def _wait(url: str, envelope: dict[str, Any]) -> dict[str, Any]:
+    job_id = envelope.get("job_id")
+    if not job_id:
+        return envelope
+    deadline = time.monotonic() + 300
+    while time.monotonic() < deadline:
+        status = _call(url, "jobs_get_status", {"job_id": job_id, "include_result": True})
+        if status.get("status") == "completed":
+            return status
+        if status.get("status") in {"failed", "cancelled", "interrupted"}:
+            raise RuntimeError(json.dumps(status, indent=2))
+        time.sleep(0.1)
+    raise TimeoutError(f"RenderDoc MCP job {job_id} did not finish")
+
+
+def _tool(url: str, suffix: str) -> str:
+    names: list[str] = []
+    cursor = None
+    for _ in range(20):
+        response = _post(url, "tools/list", {"cursor": cursor} if cursor else None)
+        result = response.get("result", {})
+        names.extend(tool["name"] for tool in result.get("tools", []))
+        cursor = result.get("nextCursor")
+        if not cursor:
+            break
+    matches = [name for name in names if name == suffix or name.endswith(f"__{suffix}")]
+    if len(matches) != 1:
+        raise RuntimeError(f"Expected one tool ending in {suffix!r}, found {matches!r}")
+    return matches[0]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--renderdoc", required=True)
+    parser.add_argument("--program", required=True)
+    parser.add_argument("--artifacts", type=Path, default=Path("artifacts"))
+    args = parser.parse_args()
+
+    artifacts = args.artifacts.resolve()
+    artifacts.mkdir(parents=True, exist_ok=True)
+    os.environ["DCC_MCP_RENDERDOC_CMD"] = str(Path(args.renderdoc).resolve())
+    program = str(Path(args.program).resolve())
+
+    server = RenderDocMcpServer(port=0)
+    try:
+        server.register_builtin_actions()
+        server.start(install_atexit_hook=False)
+        url = server.mcp_url
+        _call(url, "load_skill", {"skill_name": "renderdoc-capture"})
+        _call(url, "load_skill", {"skill_name": "renderdoc-analysis"})
+        version = _wait(url, _call(url, _tool(url, "get_version")))
+        capture_job = _call(
+            url,
+            _tool(url, "capture_program"),
+            {
+                "executable": program,
+                "output_template": str(artifacts / "smoke"),
+                "arguments": [str(artifacts / "smoke")],
+                "working_directory": str(Path(program).parent),
+            },
+        )
+        _wait(url, capture_job)
+        captures = sorted(artifacts.glob("*.rdc"))
+        if not captures:
+            raise RuntimeError("MCP capture tool did not create an .rdc file")
+        capture = str(captures[-1])
+        inspection = _wait(
+            url,
+            _call(url, _tool(url, "inspect_capture"), {"capture_file": capture}),
+        )
+        _wait(
+            url,
+            _call(
+                url,
+                _tool(url, "export_thumbnail"),
+                {"capture_file": capture, "output_file": str(artifacts / "smoke.png")},
+            ),
+        )
+        _wait(
+            url,
+            _call(
+                url,
+                _tool(url, "export_timeline"),
+                {"capture_file": capture, "output_file": str(artifacts / "smoke.json")},
+            ),
+        )
+        assert (artifacts / "smoke.png").stat().st_size > 0
+        assert (artifacts / "smoke.json").stat().st_size > 0
+        print(json.dumps({"version": version, "inspection_job": inspection}))
+    finally:
+        server.stop()
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_renderdoc-0.2.0/tests/renderdoc_smoke.c

@@ -0,0 +1,71 @@
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+#include <dlfcn.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "renderdoc_app.h"
+
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
+
+typedef GLXContext (*CreateContextAttribs)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
+
+int main(int argc, char **argv) {
+    Display *display = XOpenDisplay(NULL);
+    int count = 0;
+    int attributes[] = {GLX_X_RENDERABLE, True, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+                        GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DOUBLEBUFFER, True, None};
+    GLXFBConfig *configs = display ? glXChooseFBConfig(display, DefaultScreen(display), attributes, &count) : NULL;
+    XVisualInfo *visual = count > 0 ? glXGetVisualFromFBConfig(display, configs[0]) : NULL;
+    CreateContextAttribs create_context =
+        (CreateContextAttribs)glXGetProcAddressARB((const GLubyte *)"glXCreateContextAttribsARB");
+    if (!display || !visual || !create_context) return 2;
+
+    Window root = RootWindow(display, visual->screen);
+    Colormap color_map = XCreateColormap(display, root, visual->visual, AllocNone);
+    XSetWindowAttributes window_attributes = {0};
+    window_attributes.colormap = color_map;
+    window_attributes.event_mask = ExposureMask;
+    Window window = XCreateWindow(display, root, 0, 0, 320, 200, 0, visual->depth, InputOutput,
+                                  visual->visual, CWColormap | CWEventMask, &window_attributes);
+    int context_attributes[] = {GLX_CONTEXT_MAJOR_VERSION_ARB, 3, GLX_CONTEXT_MINOR_VERSION_ARB, 2,
+                                GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB, None};
+    GLXContext context = create_context(display, configs[0], NULL, True, context_attributes);
+    XFree(configs);
+    if (!context) return 2;
+    XMapWindow(display, window);
+    glXMakeCurrent(display, window, context);
+
+    pRENDERDOC_GetAPI get_api = (pRENDERDOC_GetAPI)dlsym(RTLD_DEFAULT, "RENDERDOC_GetAPI");
+    RENDERDOC_API_1_1_2 *api = NULL;
+    if (!get_api || !get_api(eRENDERDOC_API_Version_1_1_2, (void **)&api)) return 3;
+    if (argc > 1) api->SetCaptureFilePathTemplate(argv[1]);
+
+    glViewport(0, 0, 320, 200);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glXSwapBuffers(display, window);
+    glFinish();
+
+    api->StartFrameCapture(NULL, NULL);
+    if (!api->IsFrameCapturing()) return 4;
+    glViewport(0, 0, 320, 200);
+    glClearColor(0.1f, 0.4f, 0.8f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glXSwapBuffers(display, window);
+    glFinish();
+    if (!api->EndFrameCapture(NULL, NULL)) return 5;
+    usleep(200000);
+
+    glXMakeCurrent(display, None, NULL);
+    glXDestroyContext(display, context);
+    XDestroyWindow(display, window);
+    XCloseDisplay(display);
+    printf("captured=%u\n", api->GetNumCaptures());
+    return 0;
+}

dcc_mcp_renderdoc-0.2.0/tests/test_download.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+import pytest
+
+from tools.download_latest_renderdoc import _safe_destination, latest_version
+
+
+def test_latest_version_uses_numeric_ordering():
+    html = "/stable/1.9/renderdoc_1.9.tar.gz /stable/1.45/renderdoc_1.45.tar.gz"
+    assert latest_version(html) == "1.45"
+
+
+def test_archive_member_must_remain_below_destination(tmp_path: Path):
+    with pytest.raises(RuntimeError, match="escapes destination"):
+        _safe_destination(tmp_path, "../outside")

dcc_mcp_renderdoc-0.2.0/tests/test_package.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from dcc_mcp_renderdoc.server import RenderDocMcpServer
+
+
+def test_server_constructs_with_headless_contract():
+    server = RenderDocMcpServer(port=0)
+    try:
+        assert server._options.server_name == "dcc-mcp-renderdoc"
+        assert server._options.dcc_name == "renderdoc"
+    finally:
+        server.stop()
+
+
+def test_bundled_skills_and_release_workflow_exist():
+    root = Path(__file__).parents[1]
+    skills = root / "src" / "dcc_mcp_renderdoc" / "skills"
+    assert {path.name for path in skills.iterdir() if path.is_dir()} == {
+        "renderdoc-analysis",
+        "renderdoc-capture",
+    }
+    assert (root / ".github" / "workflows" / "release.yml").is_file()

dcc_mcp_renderdoc-0.2.0/tests/test_runtime.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from subprocess import CompletedProcess
+
+import pytest
+
+from dcc_mcp_renderdoc import runtime
+
+
+def test_parse_capture_xml_summarizes_stable_fields(tmp_path: Path):
+    xml_file = tmp_path / "capture.xml"
+    xml_file.write_text(
+        """<rdc><header><driver id="2">Vulkan</driver><machineIdent>123</machineIdent>
+        <thumbnail width="640" height="360" /></header><chunks version="17">
+        <chunk name="vkCmdDraw"/><chunk name="vkCmdDraw"/><chunk name="Present"/>
+        </chunks></rdc>""",
+        encoding="utf-8",
+    )
+
+    result = runtime.parse_capture_xml(str(xml_file), representative_limit=2)
+
+    assert result["driver"] == {"id": "2", "name": "Vulkan"}
+    assert result["thumbnail"] == {"width": 640, "height": 360}
+    assert result["chunk_count"] == 3
+    assert result["chunk_frequencies"][0] == {"name": "vkCmdDraw", "count": 2}
+    assert result["representative_chunks"] == ["vkCmdDraw", "vkCmdDraw"]
+
+
+def test_resolve_renderdoccmd_prefers_explicit_file(tmp_path: Path):
+    executable = tmp_path / "renderdoccmd"
+    executable.touch()
+    assert runtime.resolve_renderdoccmd(str(executable)) == executable.resolve()
+
+
+def test_capture_program_uses_argument_vector_and_reports_new_capture(tmp_path, monkeypatch):
+    target = tmp_path / "game.exe"
+    target.touch()
+    observed = {}
+
+    def fake_run(arguments, **_kwargs):
+        observed["arguments"] = arguments
+        (tmp_path / "capture_frame1.rdc").touch()
+        return CompletedProcess(arguments, 0, "captured", "")
+
+    monkeypatch.setattr(runtime, "_run", fake_run)
+    result = runtime.capture_program(
+        str(target),
+        str(tmp_path / "capture"),
+        arguments=["--scene", "demo"],
+    )
+
+    assert observed["arguments"][-3:] == [str(target.resolve()), "--scene", "demo"]
+    assert result["captures"] == [str((tmp_path / "capture_frame1.rdc").resolve())]
+
+
+def test_invalid_capture_is_rejected(tmp_path: Path):
+    with pytest.raises(runtime.RenderDocError, match="not .rdc"):
+        runtime.inspect_capture(str(tmp_path / "missing.rdc"))

dcc_mcp_renderdoc-0.2.0/tools/__init__.py

@@ -0,0 +1 @@
+"""Repository tooling helpers."""

dcc_mcp_renderdoc-0.2.0/tools/download_latest_renderdoc.py

@@ -0,0 +1,89 @@
+"""Download the latest stable RenderDoc bundle from the official builds page."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import shutil
+import sys
+import tarfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+BUILDS_URL = "https://renderdoc.org/builds"
+
+
+def latest_version(html: str) -> str:
+    versions = set(re.findall(r"/stable/([0-9]+\.[0-9]+)/", html))
+    if not versions:
+        raise RuntimeError("No stable RenderDoc versions found on the official builds page")
+    return max(versions, key=lambda value: tuple(int(part) for part in value.split(".")))
+
+
+def _safe_destination(root: Path, member_name: str) -> Path:
+    destination = (root / member_name).resolve()
+    try:
+        destination.relative_to(root.resolve())
+    except ValueError as exc:
+        raise RuntimeError(f"Archive member escapes destination: {member_name}") from exc
+    return destination
+
+
+def extract_archive(archive: Path, destination: Path) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    if zipfile.is_zipfile(archive):
+        with zipfile.ZipFile(archive) as bundle:
+            for member in bundle.infolist():
+                _safe_destination(destination, member.filename)
+            bundle.extractall(destination)
+        return
+    with tarfile.open(archive, "r:gz") as bundle:
+        for member in bundle.getmembers():
+            _safe_destination(destination, member.name)
+            if member.issym() or member.islnk():
+                raise RuntimeError(f"Archive links are not accepted: {member.name}")
+        bundle.extractall(destination)
+
+
+def download_latest(output: Path, platform: str = sys.platform) -> Path:
+    request = urllib.request.Request(BUILDS_URL, headers={"User-Agent": "dcc-mcp-renderdoc"})
+    with urllib.request.urlopen(request, timeout=30) as response:
+        version = latest_version(response.read().decode("utf-8"))
+    if platform == "win32":
+        archive_name = f"RenderDoc_{version}_64.zip"
+    elif platform.startswith("linux"):
+        archive_name = f"renderdoc_{version}.tar.gz"
+    else:
+        raise RuntimeError(f"RenderDoc has no supported desktop bundle for {platform}")
+
+    version_dir = output.resolve() / version
+    command_name = "renderdoccmd.exe" if platform == "win32" else "renderdoccmd"
+    existing = next(version_dir.rglob(command_name), None) if version_dir.exists() else None
+    if existing:
+        return existing.resolve()
+
+    output.mkdir(parents=True, exist_ok=True)
+    archive = output / archive_name
+    url = f"https://renderdoc.org/stable/{version}/{archive_name}"
+    with urllib.request.urlopen(url, timeout=120) as response, archive.open("wb") as stream:
+        shutil.copyfileobj(response, stream)
+    extract_archive(archive, version_dir)
+    archive.unlink()
+    command = next(version_dir.rglob(command_name), None)
+    if command is None:
+        raise RuntimeError(f"Downloaded bundle did not contain {command_name}")
+    if platform.startswith("linux"):
+        command.chmod(command.stat().st_mode | 0o111)
+    return command.resolve()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, default=Path(".renderdoc-bin"))
+    args = parser.parse_args()
+    print(download_latest(args.output))
+
+
+if __name__ == "__main__":
+    main()

dcc_mcp_renderdoc-0.2.0/tools/lint_skills.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+from dcc_mcp_core import validate_skill
+
+skills_root = Path(__file__).parents[1] / "src" / "dcc_mcp_renderdoc" / "skills"
+reports = [validate_skill(str(path)) for path in skills_root.iterdir() if path.is_dir()]
+assert all(report.is_clean for report in reports), [report.issues for report in reports]
+print(f"validated {len(reports)} bundled skills")