dcc-mcp-renderdoc 0.2.0__tar.gz → 0.3.0__tar.gz

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

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

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.3.0](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.2.1...v0.3.0) (2026-07-16)
+
+
+### Features
+
+* automate interactive frame capture ([3131ed3](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/3131ed35a5f252993c7a099a05071e73313126c3))
+* default adapter instances to dynamic ports ([#6](https://github.com/dcc-mcp/dcc-mcp-renderdoc/issues/6)) ([b4bd77b](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/b4bd77bfc487755fc1aadc390997be638382ada1))
+
+
+### Bug Fixes
+
+* keep capture diagnostics cross-platform ([a477bfd](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/a477bfd9f32d609f141d6d77d0576a861fd60bf1))
+* report capture target diagnostics ([861c852](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/861c8528b35a13fdd8441a89ede80f967e811839))
+
+## [0.2.1](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.2.0...v0.2.1) (2026-07-15)
+
+
+### Bug Fixes
+
+* keep runtime version aligned with package ([b3eb754](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/b3eb754c98416dd1d0b467691949e61bd679cb88))
+
 ## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.1.0...v0.2.0) (2026-07-15)
 
 

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcc-mcp-renderdoc
-Version: 0.2.0
+Version: 0.3.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
@@ -18,7 +18,7 @@ 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
+Requires-Dist: dcc-mcp-core<1.0.0,>=0.19.45
 Provides-Extra: dev
 Requires-Dist: build>=1.2; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
@@ -49,9 +49,15 @@ dcc-mcp-renderdoc
 
 On Windows, set the variable to `renderdoccmd.exe`.
 
+Each adapter instance uses an OS-assigned MCP port and registers it for CLI discovery. Connect
+through the stable gateway at `http://127.0.0.1:9765/mcp`; set
+`DCC_MCP_RENDERDOC_PORT` only when a fixed direct endpoint is required.
+
 ## Agent workflows
 
 - Launch a game or test executable under RenderDoc and wait for a typed `.rdc` capture.
+- Trigger F12 automatically after a configurable delay, with optional child-process window focus.
+- Inject into a visible Windows process that had to be launched by a platform client, then trigger and collect a 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.
@@ -59,6 +65,11 @@ On Windows, set the variable to `renderdoccmd.exe`.
 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.
 
+For interactive Windows programs, pass `trigger_after_secs` to `capture_program`. When a launcher
+creates the rendered child process, also pass `trigger_process_name`. Use `capture_process` only
+when the target is already running; late injection may not capture graphics devices created before
+RenderDoc was attached.
+
 ## Real CI
 
 CI discovers the current stable RenderDoc build from the official downloads page. It compiles a
@@ -76,4 +87,3 @@ 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 → dcc_mcp_renderdoc-0.3.0}/README.md

@@ -21,9 +21,15 @@ dcc-mcp-renderdoc
 
 On Windows, set the variable to `renderdoccmd.exe`.
 
+Each adapter instance uses an OS-assigned MCP port and registers it for CLI discovery. Connect
+through the stable gateway at `http://127.0.0.1:9765/mcp`; set
+`DCC_MCP_RENDERDOC_PORT` only when a fixed direct endpoint is required.
+
 ## Agent workflows
 
 - Launch a game or test executable under RenderDoc and wait for a typed `.rdc` capture.
+- Trigger F12 automatically after a configurable delay, with optional child-process window focus.
+- Inject into a visible Windows process that had to be launched by a platform client, then trigger and collect a 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.
@@ -31,6 +37,11 @@ On Windows, set the variable to `renderdoccmd.exe`.
 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.
 
+For interactive Windows programs, pass `trigger_after_secs` to `capture_program`. When a launcher
+creates the rendered child process, also pass `trigger_process_name`. Use `capture_process` only
+when the target is already running; late injection may not capture graphics devices created before
+RenderDoc was attached.
+
 ## Real CI
 
 CI discovers the current stable RenderDoc build from the official downloads page. It compiles a
@@ -48,4 +59,3 @@ 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 → dcc_mcp_renderdoc-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dcc-mcp-renderdoc"
-version = "0.2.0"
+version = "0.3.0"
 description = "RenderDoc capture and replay automation skills for DCC-MCP"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -21,7 +21,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Topic :: Games/Entertainment",
 ]
-dependencies = ["dcc-mcp-core>=0.19.38,<1.0.0"]
+dependencies = ["dcc-mcp-core>=0.19.45,<1.0.0"]
 
 [project.urls]
 Homepage = "https://github.com/dcc-mcp/dcc-mcp-renderdoc"

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/release-please-config.json

@@ -1,2 +1 @@
-{"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"}]}}}
-
+{"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"},{"type":"toml","path":"uv.lock","jsonpath":"$.package[?(@.name=='dcc-mcp-renderdoc')].version"}]}}}

dcc_mcp_renderdoc-0.3.0/src/dcc_mcp_renderdoc/__version__.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "0.3.0"  # x-release-please-version

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/src/dcc_mcp_renderdoc/runtime.py

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 import os
+import re
 import shutil
 import subprocess
+import sys
 import tempfile
+import time
 import xml.etree.ElementTree as ET
 from collections import Counter
 from pathlib import Path
@@ -39,6 +42,7 @@ def _run(
     *,
     timeout_secs: int,
     command: Optional[str] = None,
+    accept_launched_id: bool = False,
 ) -> subprocess.CompletedProcess[str]:
     executable = resolve_renderdoccmd(command)
     try:
@@ -56,7 +60,13 @@ def _run(
         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}")
+        launched = re.search(r"Launched as ID (\d+)", detail)
+        if not (
+            accept_launched_id
+            and launched is not None
+            and int(launched.group(1)) == result.returncode
+        ):
+            raise RenderDocError(f"RenderDoc exited with code {result.returncode}: {detail}")
     return result
 
 
@@ -75,6 +85,9 @@ def capture_program(
     wait_for_exit: bool = True,
     api_validation: bool = False,
     hook_children: bool = False,
+    trigger_after_secs: Optional[float] = None,
+    trigger_process_name: Optional[str] = None,
+    capture_wait_secs: int = 30,
     timeout_secs: int = 300,
     command: Optional[str] = None,
 ) -> dict[str, Any]:
@@ -90,34 +103,233 @@ def capture_program(
 
     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:
+    effective_wait_for_exit = wait_for_exit and trigger_after_secs is None
+    if effective_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,
+    result = _run(
+        cli_args,
+        timeout_secs=timeout_secs,
+        command=command,
+        accept_launched_id=not effective_wait_for_exit,
     )
+    target_pid: Optional[int] = None
+    if trigger_after_secs is not None:
+        time.sleep(max(0.0, trigger_after_secs))
+        target_pid = _wait_for_visible_process(
+            trigger_process_name or target.name,
+            min(capture_wait_secs, 30),
+        )
+        focused = _trigger_capture_hotkey(target_pid)
+        captures = _wait_for_captures(output.parent, before, capture_wait_secs)
+    else:
+        focused = False
+        captures = _new_captures(output.parent, before)
     if not captures:
         output_detail = "\n".join(
             part.strip() for part in (result.stdout, result.stderr) if part.strip()
         )[-2000:]
+        diagnostics = _capture_failure_diagnostics(
+            process_id=target_pid,
+            process_name=trigger_process_name or target.name,
+            focused=focused,
+        )
         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}"
+            "No new .rdc capture appeared; ensure the target presents a frame and was hooked "
+            f"before creating its graphics device. {diagnostics}. "
+            f"RenderDoc output: {output_detail}"
         )
     return {
         "target": str(target),
         "captures": [str(path) for path in captures],
+        "focused_target_window": focused,
+        "stdout": result.stdout.strip(),
+    }
+
+
+def capture_process(
+    process_id: int,
+    output_template: str,
+    *,
+    working_directory: Optional[str] = None,
+    trigger_after_secs: float = 2.0,
+    capture_wait_secs: int = 30,
+    api_validation: bool = False,
+    timeout_secs: int = 60,
+    command: Optional[str] = None,
+) -> dict[str, Any]:
+    """Inject into one live process, trigger F12, and return the new capture."""
+    if process_id <= 0:
+        raise RenderDocError("Process ID must be a positive integer")
+    output = Path(output_template).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    before = {path.resolve() for path in output.parent.glob("*.rdc")}
+    cli_args = ["inject", f"--PID={process_id}", "--capture-file", str(output)]
+    if working_directory:
+        cwd = Path(working_directory).expanduser().resolve()
+        if not cwd.is_dir():
+            raise RenderDocError(f"Working directory does not exist: {cwd}")
+        cli_args.extend(["--working-dir", str(cwd)])
+    if api_validation:
+        cli_args.append("--opt-api-validation")
+    result = _run(
+        cli_args,
+        timeout_secs=timeout_secs,
+        command=command,
+        accept_launched_id=True,
+    )
+    time.sleep(max(0.0, trigger_after_secs))
+    focused = _trigger_capture_hotkey(process_id)
+    captures = _wait_for_captures(output.parent, before, capture_wait_secs)
+    if not captures:
+        output_detail = "\n".join(
+            part.strip() for part in (result.stdout, result.stderr) if part.strip()
+        )[-2000:]
+        diagnostics = _capture_failure_diagnostics(
+            process_id=process_id,
+            process_name=None,
+            focused=focused,
+        )
+        raise RenderDocError(
+            "No .rdc capture appeared after injection and F12; ensure the target window is visible "
+            f"and uses a graphics API supported by RenderDoc. {diagnostics}. "
+            f"RenderDoc output: {output_detail}"
+        )
+    return {
+        "process_id": process_id,
+        "captures": [str(path) for path in captures],
+        "focused_target_window": focused,
         "stdout": result.stdout.strip(),
     }
 
 
+def _new_captures(directory: Path, before: set[Path]) -> list[Path]:
+    return sorted(
+        (path.resolve() for path in directory.glob("*.rdc") if path.resolve() not in before),
+        key=lambda path: path.stat().st_mtime_ns,
+    )
+
+
+def _wait_for_captures(directory: Path, before: set[Path], timeout_secs: int) -> list[Path]:
+    deadline = time.monotonic() + timeout_secs
+    while time.monotonic() < deadline:
+        captures = _new_captures(directory, before)
+        if captures:
+            return captures
+        time.sleep(0.25)
+    return []
+
+
+def _trigger_capture_hotkey(process_id: Optional[int] = None) -> bool:
+    if sys.platform != "win32":
+        raise RenderDocError("Automatic F12 capture triggering is currently supported on Windows")
+    import ctypes
+    from ctypes import wintypes
+
+    user32 = ctypes.windll.user32
+    target = wintypes.HWND()
+    if process_id is not None:
+        callback_type = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
+
+        @callback_type
+        def find_window(window, _extra):
+            nonlocal target
+            owner = wintypes.DWORD()
+            user32.GetWindowThreadProcessId(window, ctypes.byref(owner))
+            if owner.value == process_id and user32.IsWindowVisible(window):
+                target = window
+                return False
+            return True
+
+        user32.EnumWindows(find_window, 0)
+        if target:
+            user32.SetForegroundWindow(target)
+            time.sleep(0.15)
+    user32.keybd_event(0x7B, 0, 0, 0)
+    user32.keybd_event(0x7B, 0, 2, 0)
+    return bool(target)
+
+
+def _wait_for_visible_process(process_name: str, timeout_secs: int) -> Optional[int]:
+    if sys.platform != "win32":
+        return None
+    deadline = time.monotonic() + timeout_secs
+    while time.monotonic() < deadline:
+        process_id = _visible_process_id(process_name)
+        if process_id is not None:
+            return process_id
+        time.sleep(0.25)
+    return None
+
+
+def _visible_process_id(process_name: str) -> Optional[int]:
+    expected = Path(process_name).name.casefold()
+    for process in _visible_processes():
+        if process["name"].casefold() == expected:
+            return int(process["process_id"])
+    return None
+
+
+def _visible_processes(limit: int = 64) -> list[dict[str, Any]]:
+    if sys.platform != "win32":
+        return []
+
+    import ctypes
+    from ctypes import wintypes
+
+    user32 = ctypes.windll.user32
+    kernel32 = ctypes.windll.kernel32
+    found: list[dict[str, Any]] = []
+    seen: set[int] = set()
+    callback_type = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
+
+    @callback_type
+    def find_window(window, _extra):
+        if not user32.IsWindowVisible(window) or len(found) >= limit:
+            return True
+        owner = wintypes.DWORD()
+        user32.GetWindowThreadProcessId(window, ctypes.byref(owner))
+        if not owner.value or owner.value in seen:
+            return True
+        process = kernel32.OpenProcess(0x1000, False, owner.value)
+        if not process:
+            return True
+        try:
+            size = wintypes.DWORD(32768)
+            path = ctypes.create_unicode_buffer(size.value)
+            if kernel32.QueryFullProcessImageNameW(process, 0, path, ctypes.byref(size)):
+                seen.add(owner.value)
+                found.append({"process_id": owner.value, "name": Path(path.value).name})
+        finally:
+            kernel32.CloseHandle(process)
+        return True
+
+    user32.EnumWindows(find_window, 0)
+    return found
+
+
+def _capture_failure_diagnostics(
+    *, process_id: Optional[int], process_name: Optional[str], focused: bool
+) -> str:
+    visible = _visible_processes()
+    if process_id is not None:
+        match = next((process for process in visible if process["process_id"] == process_id), None)
+        target = f"{match['name']}(pid={process_id})" if match else f"pid={process_id}:not-visible"
+    else:
+        target = f"{Path(process_name).name}:not-found" if process_name else "not-found"
+    snapshot = ", ".join(
+        f"{process['name']}(pid={process['process_id']})" for process in visible[:20]
+    )
+    return (
+        f"target_process={target}; focused_target_window={focused}; "
+        f"visible_processes=[{snapshot or 'none'}]"
+    )
+
+
 def _require_capture(capture_file: str) -> Path:
     path = Path(capture_file).expanduser().resolve()
     if not path.is_file() or path.suffix.lower() != ".rdc":

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/src/dcc_mcp_renderdoc/server.py

@@ -15,14 +15,14 @@ from dcc_mcp_core.server_base import DccServerBase
 from .__version__ import __version__
 from .runtime import RenderDocError, get_version
 
-DEFAULT_PORT = 8765
+DEFAULT_PORT = 0
 _server: Optional["RenderDocMcpServer"] = None
 
 
 class RenderDocMcpServer(DccServerBase):
     """Headless DCC-MCP adapter backed by renderdoccmd."""
 
-    def __init__(self, port: int = DEFAULT_PORT) -> None:
+    def __init__(self, port: Optional[int] = None) -> None:
         os.environ.setdefault("DCC_MCP_PYTHON_EXECUTABLE", sys.executable)
         options = DccServerOptions.from_env(
             "renderdoc",
@@ -43,12 +43,7 @@ class RenderDocMcpServer(DccServerBase):
 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 = RenderDocMcpServer(port)
         _server.register_builtin_actions()
         _server.start()
     return _server

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/SKILL.md

@@ -21,5 +21,10 @@ metadata:
 # 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.
+arguments, never a shell. Set `trigger_after_secs` to trigger F12 automatically on Windows.
+When using `hook_children`, set `trigger_process_name` to the child executable that should receive
+focus before F12.
 
+Use `capture_process` when Steam or another platform client must launch the target first. It
+injects into the explicit PID, focuses that visible window, triggers F12 after the requested delay,
+and waits for the resulting capture. Neither tool terminates the target process.

dcc_mcp_renderdoc-0.3.0/src/dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/capture_process.py

@@ -0,0 +1,32 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_renderdoc.runtime import capture_process
+
+
+@skill_entry
+def main(
+    process_id: int,
+    output_template: str,
+    working_directory=None,
+    trigger_after_secs: float = 2.0,
+    capture_wait_secs: int = 30,
+    api_validation: bool = False,
+    timeout_secs: int = 60,
+    **_kwargs,
+):
+    result = capture_process(
+        process_id,
+        output_template,
+        working_directory=working_directory,
+        trigger_after_secs=trigger_after_secs,
+        capture_wait_secs=capture_wait_secs,
+        api_validation=api_validation,
+        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 → dcc_mcp_renderdoc-0.3.0}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/scripts/capture_program.py

@@ -12,6 +12,9 @@ def main(
     wait_for_exit: bool = True,
     api_validation: bool = False,
     hook_children: bool = False,
+    trigger_after_secs=None,
+    trigger_process_name=None,
+    capture_wait_secs: int = 30,
     timeout_secs: int = 300,
     **_kwargs,
 ):
@@ -23,6 +26,9 @@ def main(
         wait_for_exit=wait_for_exit,
         api_validation=api_validation,
         hook_children=hook_children,
+        trigger_after_secs=trigger_after_secs,
+        trigger_process_name=trigger_process_name,
+        capture_wait_secs=capture_wait_secs,
         timeout_secs=timeout_secs,
     )
     return skill_success(f"Created {len(result['captures'])} RenderDoc capture(s).", **result)

{dcc_mcp_renderdoc-0.2.0 → dcc_mcp_renderdoc-0.3.0}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/tools.yaml

@@ -29,6 +29,9 @@ tools:
         wait_for_exit: {type: boolean, default: true}
         api_validation: {type: boolean, default: false}
         hook_children: {type: boolean, default: false}
+        trigger_after_secs: {type: number, minimum: 0, maximum: 600}
+        trigger_process_name: {type: string, minLength: 1, maxLength: 260}
+        capture_wait_secs: {type: integer, minimum: 1, maximum: 600, default: 30}
         timeout_secs: {type: integer, minimum: 1, maximum: 3600, default: 300}
       additionalProperties: false
     output_schema: {type: object}
@@ -42,4 +45,28 @@ tools:
     next-tools:
       on-success: [renderdoc_analysis__inspect_capture, renderdoc_analysis__export_thumbnail]
       on-failure: [dcc_diagnostics__audit_log]
-
+  - name: capture_process
+    description: Inject RenderDoc into one visible Windows process, focus its window, trigger F12 after a delay, and return the new .rdc file. Use when a game must be launched by its platform client. Not for hidden services or process termination.
+    input_schema:
+      type: object
+      required: [process_id, output_template]
+      properties:
+        process_id: {type: integer, minimum: 1}
+        output_template: {type: string, minLength: 1, maxLength: 1000}
+        working_directory: {type: string, maxLength: 1000}
+        trigger_after_secs: {type: number, minimum: 0, maximum: 600, default: 2}
+        capture_wait_secs: {type: integer, minimum: 1, maximum: 600, default: 30}
+        api_validation: {type: boolean, default: false}
+        timeout_secs: {type: integer, minimum: 1, maximum: 600, default: 60}
+      additionalProperties: false
+    output_schema: {type: object}
+    read_only: false
+    destructive: false
+    idempotent: false
+    execution: async
+    affinity: any
+    timeout_hint_secs: 660
+    source_file: scripts/capture_process.py
+    next-tools:
+      on-success: [renderdoc_analysis__inspect_capture, renderdoc_analysis__export_thumbnail]
+      on-failure: [dcc_diagnostics__audit_log]

dcc_mcp_renderdoc-0.3.0/tests/test_package.py

@@ -0,0 +1,65 @@
+import re
+from pathlib import Path
+
+from dcc_mcp_renderdoc import __version__
+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()
+
+
+def test_runtime_version_matches_distribution_metadata():
+    root = Path(__file__).parents[1]
+    pyproject = (root / "pyproject.toml").read_text(encoding="utf-8")
+    project_version = re.search(r'^version = "([^"]+)"$', pyproject, re.MULTILINE)
+    assert project_version is not None
+    assert __version__ == project_version.group(1)
+    lock = (root / "uv.lock").read_text(encoding="utf-8")
+    locked_project = re.search(
+        r'\[\[package\]\]\s+name = "dcc-mcp-renderdoc"\s+version = "([^"]+)"', lock
+    )
+    assert locked_project is not None
+    assert __version__ == locked_project.group(1)
+
+
+def test_start_server_defers_port_resolution_to_core(monkeypatch):
+    from types import SimpleNamespace
+
+    from dcc_mcp_renderdoc import server as server_module
+
+    ports = []
+    stub = SimpleNamespace(
+        is_running=False,
+        register_builtin_actions=lambda: None,
+        start=lambda: None,
+        stop=lambda: None,
+    )
+
+    monkeypatch.setattr(server_module, "_server", None)
+    monkeypatch.setattr(
+        server_module, "RenderDocMcpServer", lambda port=None: ports.append(port) or stub
+    )
+    monkeypatch.setenv("DCC_MCP_RENDERDOC_PORT", "8765")
+
+    server_module.start_server(0)
+    server_module.stop_server()
+    server_module.start_server()
+    server_module.stop_server()
+
+    assert ports == [0, None]

dcc_mcp_renderdoc-0.3.0/tests/test_runtime.py

@@ -0,0 +1,192 @@
+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_non_waiting_launch_accepts_renderdoc_target_id(monkeypatch, tmp_path):
+    command = tmp_path / "renderdoccmd.exe"
+    command.touch()
+    monkeypatch.setattr(
+        runtime.subprocess,
+        "run",
+        lambda *args, **kwargs: CompletedProcess(args[0], 12345, "Launched as ID 12345", ""),
+    )
+
+    result = runtime._run(
+        ["capture", "game.exe"],
+        timeout_secs=10,
+        command=str(command),
+        accept_launched_id=True,
+    )
+
+    assert result.returncode == 12345
+
+
+def test_capture_process_injects_triggers_and_reports_capture(tmp_path, monkeypatch):
+    observed = {}
+
+    def fake_run(arguments, **kwargs):
+        observed["arguments"] = arguments
+        observed["accept_launched_id"] = kwargs["accept_launched_id"]
+        return CompletedProcess(arguments, 456, "Launched as ID 456", "")
+
+    monkeypatch.setattr(runtime, "_run", fake_run)
+    monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda pid: pid == 42)
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_captures",
+        lambda directory, before, timeout: [tmp_path / "capture_frame1.rdc"],
+    )
+
+    result = runtime.capture_process(42, str(tmp_path / "capture"))
+
+    assert observed["arguments"][:2] == ["inject", "--PID=42"]
+    assert observed["accept_launched_id"] is True
+    assert result["focused_target_window"] is True
+
+
+def test_capture_program_focuses_requested_child_before_trigger(tmp_path, monkeypatch):
+    target = tmp_path / "launcher.exe"
+    target.touch()
+    observed = {}
+    monkeypatch.setattr(
+        runtime,
+        "_run",
+        lambda arguments, **kwargs: CompletedProcess(arguments, 123, "Launched as ID 123", ""),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(runtime, "_wait_for_visible_process", lambda name, timeout: 77)
+    monkeypatch.setattr(
+        runtime,
+        "_trigger_capture_hotkey",
+        lambda pid: observed.setdefault("pid", pid) == 77,
+    )
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_captures",
+        lambda directory, before, timeout: [tmp_path / "capture_frame1.rdc"],
+    )
+
+    result = runtime.capture_program(
+        str(target),
+        str(tmp_path / "capture"),
+        trigger_after_secs=1,
+        trigger_process_name="game.exe",
+    )
+
+    assert observed["pid"] == 77
+    assert result["focused_target_window"] is True
+
+
+def test_capture_program_failure_reports_missing_child_diagnostics(tmp_path, monkeypatch):
+    target = tmp_path / "launcher.exe"
+    target.touch()
+    monkeypatch.setattr(
+        runtime,
+        "_run",
+        lambda arguments, **kwargs: CompletedProcess(arguments, 123, "Launched as ID 123", ""),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(runtime, "_wait_for_visible_process", lambda name, timeout: None)
+    monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda pid: False)
+    monkeypatch.setattr(runtime, "_wait_for_captures", lambda directory, before, timeout: [])
+    monkeypatch.setattr(
+        runtime,
+        "_visible_processes",
+        lambda: [{"process_id": 12, "name": "launcher.exe"}],
+    )
+
+    with pytest.raises(runtime.RenderDocError) as error:
+        runtime.capture_program(
+            str(target),
+            str(tmp_path / "capture"),
+            trigger_after_secs=1,
+            trigger_process_name="game.exe",
+        )
+
+    message = str(error.value)
+    assert "target_process=game.exe:not-found" in message
+    assert "focused_target_window=False" in message
+    assert "visible_processes=[launcher.exe(pid=12)]" in message
+    assert "RenderDoc output: Launched as ID 123" in message
+
+
+def test_capture_process_failure_reports_injection_diagnostics(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        runtime,
+        "_run",
+        lambda arguments, **kwargs: CompletedProcess(
+            arguments, 42, "Launched as ID 42", "inject warning"
+        ),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda pid: False)
+    monkeypatch.setattr(runtime, "_wait_for_captures", lambda directory, before, timeout: [])
+    monkeypatch.setattr(
+        runtime,
+        "_visible_processes",
+        lambda: [{"process_id": 42, "name": "game.exe"}],
+    )
+
+    with pytest.raises(runtime.RenderDocError) as error:
+        runtime.capture_process(42, str(tmp_path / "capture"))
+
+    message = str(error.value)
+    assert "target_process=game.exe(pid=42)" in message
+    assert "focused_target_window=False" in message
+    assert "RenderDoc output: Launched as ID 42\ninject warning" in message
+
+
+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/.release-please-manifest.json

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

dcc_mcp_renderdoc-0.2.0/src/dcc_mcp_renderdoc/__version__.py

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

dcc_mcp_renderdoc-0.2.0/tests/test_package.py

@@ -1,22 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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"))