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

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/__version__.py

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

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/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/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/skills/renderdoc-analysis/metadata/depends.md

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

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/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/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/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/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/skills/renderdoc-capture/metadata/depends.md

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

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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,20 @@
+dcc_mcp_renderdoc/__init__.py,sha256=PtvTUY4_RsBHMB5Vlh8dc-JruF3l_jD1B0rhmVrDs8Y,163
+dcc_mcp_renderdoc/__version__.py,sha256=VDsBswzfU7gNsBkIaxxV6tsi0ixlms3WjN7HYgZJZ2g,46
+dcc_mcp_renderdoc/runtime.py,sha256=G4N-fJ4QaOYkbfmKcYJsSopOLPsMGAsk4tWvMs9sezk,9135
+dcc_mcp_renderdoc/server.py,sha256=pts-cHn_wyr64cDticPOIfhs2Dgs5DAp62TSPwvO-YM,2075
+dcc_mcp_renderdoc/skills/renderdoc-analysis/SKILL.md,sha256=isfpOP96bGnJbanUKVfsK-sYIGO14sLRNSOFz6mz_Po,837
+dcc_mcp_renderdoc/skills/renderdoc-analysis/tools.yaml,sha256=9UvHc9_oPv7Vsgo9EUun50v_0Uw26-Hasxm-o8WjIqA,2623
+dcc_mcp_renderdoc/skills/renderdoc-analysis/metadata/depends.md,sha256=oPXRkRwg5Q0bNsyQbM15Zo0kW0kf2HngdhKNVoM61f4,19
+dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/export_thumbnail.py,sha256=j8Gm5QCZPpD-6kCuROkCnwwFuqmmF9-DxDon8ieVi_s,443
+dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/export_timeline.py,sha256=RIgRXH3ZDt0TbM43bpq-pYZnqHPpxjuKRuI2jBh_L8E,409
+dcc_mcp_renderdoc/skills/renderdoc-analysis/scripts/inspect_capture.py,sha256=-20dNoM7DoD0_B-CENLscipjYAdv30LGMfZEbdbtAHc,446
+dcc_mcp_renderdoc/skills/renderdoc-capture/SKILL.md,sha256=W9u3CxjCXBNRH_JWLD0Roj9iRo_WR_z_zLD-AGsOD0E,826
+dcc_mcp_renderdoc/skills/renderdoc-capture/tools.yaml,sha256=vYyif3bExXaG6foVsr_stUCW3OSmOay0hN0bAqKhxc8,1878
+dcc_mcp_renderdoc/skills/renderdoc-capture/metadata/depends.md,sha256=oPXRkRwg5Q0bNsyQbM15Zo0kW0kf2HngdhKNVoM61f4,19
+dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/capture_program.py,sha256=ny4KUNouJD7fUYhh8PWDEoP_Npr4lezcZx8aZQ3Blpw,870
+dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/get_version.py,sha256=qog2c4GEykHZDTvWMGa7s8KxgZ1Skez9qek1TTytogs,311
+dcc_mcp_renderdoc-0.2.0.dist-info/METADATA,sha256=5erLYp2CAce_dVmIJMV8O6W1McRxgdPyw4kIour8K3k,2873
+dcc_mcp_renderdoc-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+dcc_mcp_renderdoc-0.2.0.dist-info/entry_points.txt,sha256=R0g0vPcVzarQHA-R65uVHu_R8xU0s4JRVaJ9r-aktIs,137
+dcc_mcp_renderdoc-0.2.0.dist-info/licenses/LICENSE,sha256=tI9ZnJarjIkjC-Mje0HidFJgMMAhrK9qV-JdFSshBZw,1066
+dcc_mcp_renderdoc-0.2.0.dist-info/RECORD,,

dcc_mcp_renderdoc-0.2.0.dist-info/WHEEL

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

dcc_mcp_renderdoc-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+dcc-mcp-renderdoc = dcc_mcp_renderdoc.server:main
+
+[dcc_mcp.adapters]
+renderdoc = dcc_mcp_renderdoc:RenderDocMcpServer

dcc_mcp_renderdoc-0.2.0.dist-info/licenses/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.
+