dcc-mcp-renderdoc 0.3.1__tar.gz → 0.3.3__tar.gz

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

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

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.3}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.3.3](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.3.2...v0.3.3) (2026-07-22)
+
+
+### Bug Fixes
+
+* accept POSIX target ident exit status ([e35d14e](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/e35d14ed7dfdd429f5356ac8a5d5a98411a9dc28))
+* harden target control lifecycle ([1a1eca8](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/1a1eca82fb453ec40b11a33791160d6074e70a6f))
+* isolate target control sidecar ([2e16b2b](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/2e16b2b009c76136a5ad2889c4943c458401923a))
+* normalize target names across platforms ([44602a0](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/44602a0fca3fd2749688f56f169280d18ddcb989))
+* trigger captures through RenderDoc Target Control ([68d93aa](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/68d93aa9c0629b61cac75275ca53a55a65f29729))
+* trigger captures through target control ([f0a11c8](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/f0a11c844a5597c0ae6b022a8ec07c32d7a15806))
+* verify target before capture trigger ([a392e9f](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/a392e9fc974152d5d2dc183c1ed8b60ed15c2195))
+
+## [0.3.2](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.3.1...v0.3.2) (2026-07-22)
+
+
+### Bug Fixes
+
+* keep capture controller alive through trigger ([#11](https://github.com/dcc-mcp/dcc-mcp-renderdoc/issues/11)) ([1fb7bed](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/1fb7bed40dfb027b148a14cefd01c53028891d56))
+
 ## [0.3.1](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.3.0...v0.3.1) (2026-07-22)
 
 

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcc-mcp-renderdoc
-Version: 0.3.1
+Version: 0.3.3
 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
@@ -78,8 +78,8 @@ attach a stable session id with `--meta-json`, query `dcc-mcp-cli stats --range
 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.
+conversion. Delayed capture uses RenderDoc's official Target Control API through the sibling
+`qrenderdoc` bundled Python runtime, without foreground focus or synthetic keyboard input.
 
 ## Install
 
@@ -103,8 +103,8 @@ through the stable gateway at `http://127.0.0.1:9765/mcp`; set
 ## 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.
+- Trigger a capture through official Target Control after a configurable delay.
+- Inject into a 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.
@@ -112,16 +112,27 @@ through the stable gateway at `http://127.0.0.1:9765/mcp`; set
 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.
+Pass `trigger_after_secs` to `capture_program` for a Target Control trigger. This requires
+`qrenderdoc` beside `renderdoccmd`. The official RenderDoc runtime supports Windows and Linux;
+macOS is covered only by this project's Python unit tests. Linux Target Control requires an X or
+Wayland display, so headless hosts must run under Xvfb (or explicitly configure a working Qt
+platform). The official Linux archive does not bundle Qt's `offscreen` platform plugin. Each
+sidecar uses an isolated Qt data profile with RenderDoc analytics explicitly opted out, preventing
+the first-run consent dialog without reading or changing the user's qrenderdoc configuration.
+
+When a launcher creates the rendered child process, set `hook_children=true` and pass
+`trigger_process_name`. The adapter first checks the launched target itself; if its name does not
+match, it follows only that target's official `NewChild` messages to find a unique named child. A
+child name without child hooking fails before launch. 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
-small OpenGL program, captures a real frame under Xvfb, calls the MCP analysis tool against the
-resulting `.rdc`, and verifies thumbnail and timeline exports.
+CI discovers the current stable Linux RenderDoc build from the official downloads page. It
+compiles a small OpenGL program, requests a real frame through Target Control under Xvfb using
+Qt's bundled `xcb` platform, asserts the structured trigger mode, calls the MCP analysis tool
+against the resulting `.rdc`, and verifies thumbnail and timeline exports.
 
 ## Development
 

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.3}/README.md

@@ -50,8 +50,8 @@ attach a stable session id with `--meta-json`, query `dcc-mcp-cli stats --range
 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.
+conversion. Delayed capture uses RenderDoc's official Target Control API through the sibling
+`qrenderdoc` bundled Python runtime, without foreground focus or synthetic keyboard input.
 
 ## Install
 
@@ -75,8 +75,8 @@ through the stable gateway at `http://127.0.0.1:9765/mcp`; set
 ## 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.
+- Trigger a capture through official Target Control after a configurable delay.
+- Inject into a 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.
@@ -84,16 +84,27 @@ through the stable gateway at `http://127.0.0.1:9765/mcp`; set
 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.
+Pass `trigger_after_secs` to `capture_program` for a Target Control trigger. This requires
+`qrenderdoc` beside `renderdoccmd`. The official RenderDoc runtime supports Windows and Linux;
+macOS is covered only by this project's Python unit tests. Linux Target Control requires an X or
+Wayland display, so headless hosts must run under Xvfb (or explicitly configure a working Qt
+platform). The official Linux archive does not bundle Qt's `offscreen` platform plugin. Each
+sidecar uses an isolated Qt data profile with RenderDoc analytics explicitly opted out, preventing
+the first-run consent dialog without reading or changing the user's qrenderdoc configuration.
+
+When a launcher creates the rendered child process, set `hook_children=true` and pass
+`trigger_process_name`. The adapter first checks the launched target itself; if its name does not
+match, it follows only that target's official `NewChild` messages to find a unique named child. A
+child name without child hooking fails before launch. 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
-small OpenGL program, captures a real frame under Xvfb, calls the MCP analysis tool against the
-resulting `.rdc`, and verifies thumbnail and timeline exports.
+CI discovers the current stable Linux RenderDoc build from the official downloads page. It
+compiles a small OpenGL program, requests a real frame through Target Control under Xvfb using
+Qt's bundled `xcb` platform, asserts the structured trigger mode, calls the MCP analysis tool
+against the resulting `.rdc`, and verifies thumbnail and timeline exports.
 
 ## Development
 

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dcc-mcp-renderdoc"
-version = "0.3.1"
+version = "0.3.3"
 description = "RenderDoc capture and replay automation skills for DCC-MCP"
 readme = "README.md"
 requires-python = ">=3.9"

dcc_mcp_renderdoc-0.3.3/src/dcc_mcp_renderdoc/__version__.py

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

dcc_mcp_renderdoc-0.3.3/src/dcc_mcp_renderdoc/_target_control.py

@@ -0,0 +1,185 @@
+"""RenderDoc 1.45 bundled-Python bridge for headless Target Control capture."""
+
+import json
+import os
+import time
+
+
+def _positive_int(name):
+    value = int(os.environ[name])
+    if value <= 0:
+        raise ValueError("{} must be positive".format(name))
+    return value
+
+
+def _nonnegative_float(name):
+    value = float(os.environ[name])
+    if value < 0:
+        raise ValueError("{} must not be negative".format(name))
+    return value
+
+
+def _open_target(rd, ident):
+    target = rd.CreateTargetControl("", ident, "dcc-mcp-renderdoc", False)
+    if target is None:
+        raise RuntimeError("RenderDoc target ident {} is busy or unavailable".format(ident))
+    if not target.Connected():
+        busy_client = target.GetBusyClient()
+        detail = " (busy client: {})".format(busy_client) if busy_client else ""
+        target.Shutdown()
+        raise RuntimeError("could not connect to RenderDoc target ident {}{}".format(ident, detail))
+    return target
+
+
+def _target_name_matches(actual, expected):
+    actual = str(actual).replace("\\", "/").rsplit("/", 1)[-1].casefold()
+    expected = str(expected).replace("\\", "/").rsplit("/", 1)[-1].casefold()
+    return (
+        actual == expected
+        or (actual.endswith(".exe") and actual[:-4] == expected)
+        or (expected.endswith(".exe") and expected[:-4] == actual)
+    )
+
+
+def _wait_for_child_target(rd, parent, target_name, trigger_at, deadline):
+    matches = []
+    quiet_deadline = None
+    try:
+        while time.monotonic() < deadline:
+            now = time.monotonic()
+            if (
+                len(matches) == 1
+                and quiet_deadline is not None
+                and now >= trigger_at
+                and now >= quiet_deadline
+            ):
+                return matches.pop()
+            message = parent.ReceiveMessage(None)
+            if message is not None and message.type == rd.TargetControlMessageType.NewChild:
+                child_ident = int(message.newChild.ident)
+                child_pid = int(message.newChild.processId)
+                child = _open_target(rd, child_ident)
+                try:
+                    if int(child.GetPID()) != child_pid:
+                        raise RuntimeError(
+                            "RenderDoc child target PID did not match NewChild message"
+                        )
+                    if _target_name_matches(child.GetTarget(), target_name):
+                        matches.append(child)
+                        child = None
+                finally:
+                    if child is not None:
+                        child.Shutdown()
+                if matches:
+                    if len(matches) > 1:
+                        raise RuntimeError("multiple child targets matched {}".format(target_name))
+                    quiet_deadline = time.monotonic() + 0.25
+                    if quiet_deadline > deadline:
+                        raise RuntimeError("insufficient time to select a unique child target")
+                continue
+            if message is not None and message.type == rd.TargetControlMessageType.Disconnected:
+                if len(matches) == 1:
+                    return matches.pop()
+                raise RuntimeError("RenderDoc parent Target Control disconnected before child")
+            for match in matches:
+                child_message = match.ReceiveMessage(None)
+                if (
+                    child_message is not None
+                    and child_message.type == rd.TargetControlMessageType.Disconnected
+                ):
+                    raise RuntimeError("RenderDoc child Target Control disconnected before trigger")
+            time.sleep(0.05)
+        if len(matches) == 1:
+            raise RuntimeError("insufficient time to select a unique child target")
+        raise RuntimeError("no child target matched {}".format(target_name))
+    finally:
+        for match in matches:
+            match.Shutdown()
+
+
+def _pump_until(rd, target, deadline):
+    while time.monotonic() < deadline:
+        message = target.ReceiveMessage(None)
+        if message is not None and message.type == rd.TargetControlMessageType.Disconnected:
+            raise RuntimeError("RenderDoc Target Control disconnected before trigger")
+        time.sleep(0.05)
+
+
+def main():
+    status_path = os.environ.get("DCC_MCP_RENDERDOC_TARGET_STATUS")
+    status = {
+        "schema_version": 1,
+        "connected": False,
+        "triggered": False,
+        "shutdown": False,
+        "timed_out": False,
+        "target_pid": None,
+        "capture_path": None,
+        "error": None,
+    }
+    target = None
+    try:
+        import renderdoc as rd
+
+        ident = _positive_int("DCC_MCP_RENDERDOC_TARGET_IDENT")
+        capture_wait_secs = _positive_int("DCC_MCP_RENDERDOC_TARGET_TIMEOUT_SECS")
+        trigger_after_secs = _nonnegative_float("DCC_MCP_RENDERDOC_TRIGGER_AFTER_SECS")
+        target_name = os.environ.get("DCC_MCP_RENDERDOC_TARGET_NAME", "").strip()
+        expected_pid_value = os.environ.get("DCC_MCP_RENDERDOC_EXPECTED_PID", "").strip()
+        expected_pid = int(expected_pid_value) if expected_pid_value else None
+        if expected_pid is not None and expected_pid <= 0:
+            raise ValueError("DCC_MCP_RENDERDOC_EXPECTED_PID must be positive")
+        trigger_at = time.monotonic() + trigger_after_secs
+        capture_deadline = trigger_at + capture_wait_secs
+        target = _open_target(rd, ident)
+        if target_name and not _target_name_matches(target.GetTarget(), target_name):
+            child = _wait_for_child_target(rd, target, target_name, trigger_at, capture_deadline)
+            try:
+                target.Shutdown()
+            except BaseException:
+                child.Shutdown()
+                raise
+            target = child
+        status["connected"] = True
+        status["target_pid"] = int(target.GetPID())
+        if expected_pid is not None and status["target_pid"] != expected_pid:
+            raise RuntimeError(
+                "RenderDoc target PID {} did not match expected PID {}".format(
+                    status["target_pid"], expected_pid
+                )
+            )
+        _pump_until(rd, target, trigger_at)
+        target.TriggerCapture(1)
+        status["triggered"] = True
+        while time.monotonic() < capture_deadline:
+            message = target.ReceiveMessage(None)
+            if message is not None and message.type == rd.TargetControlMessageType.NewCapture:
+                status["capture_path"] = str(message.newCapture.path)
+                break
+            if message is not None and message.type == rd.TargetControlMessageType.Disconnected:
+                raise RuntimeError("RenderDoc Target Control disconnected before capture")
+            time.sleep(0.05)
+        if status["capture_path"] is None:
+            status["timed_out"] = True
+            raise RuntimeError("timed out waiting for RenderDoc NewCapture")
+    except BaseException as exc:
+        status["error"] = str(exc)
+    finally:
+        if target is not None:
+            try:
+                target.Shutdown()
+                status["shutdown"] = True
+                target = None
+            except BaseException as exc:
+                status["error"] = status["error"] or ("Target Control shutdown failed: " + str(exc))
+        if status_path:
+            with open(status_path, "w") as status_file:
+                json.dump(status, status_file)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BaseException:
+        pass
+    raise SystemExit(0)