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

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

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

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

@@ -1,5 +1,12 @@
 # Changelog
 
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcc-mcp-renderdoc
-Version: 0.3.1
+Version: 0.3.2
 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

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

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

dcc_mcp_renderdoc-0.3.2/src/dcc_mcp_renderdoc/__version__.py

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

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.2}/src/dcc_mcp_renderdoc/runtime.py

@@ -8,6 +8,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 import xml.etree.ElementTree as ET
 from collections import Counter
@@ -19,6 +20,81 @@ class RenderDocError(RuntimeError):
     """Raised when a RenderDoc operation cannot satisfy its contract."""
 
 
+class _CaptureController:
+    def __init__(self, process: Any, stdout: list[str], stderr: list[str], readers: list[Any]):
+        self.process = process
+        self.stdout = stdout
+        self.stderr = stderr
+        self.readers = readers
+
+    def output(self) -> tuple[str, str]:
+        return "".join(self.stdout), "".join(self.stderr)
+
+    def close(self) -> None:
+        if self.process.poll() is None:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+                self.process.wait(timeout=5)
+        for reader in self.readers:
+            reader.join(timeout=1)
+
+
+def _start_capture_controller(
+    arguments: Sequence[str], *, timeout_secs: int, command: Optional[str]
+) -> _CaptureController:
+    executable = resolve_renderdoccmd(command)
+    try:
+        process = subprocess.Popen(
+            [str(executable), *arguments],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            shell=False,
+        )
+    except OSError as exc:
+        raise RenderDocError(f"Could not start RenderDoc: {exc}") from exc
+
+    stdout: list[str] = []
+    stderr: list[str] = []
+
+    def read_stream(stream: Any, output: list[str]) -> None:
+        for chunk in iter(lambda: stream.read(1), ""):
+            output.append(chunk)
+
+    readers = [
+        threading.Thread(target=read_stream, args=(process.stdout, stdout), daemon=True),
+        threading.Thread(target=read_stream, args=(process.stderr, stderr), daemon=True),
+    ]
+    for reader in readers:
+        reader.start()
+    controller = _CaptureController(process, stdout, stderr, readers)
+    deadline = time.monotonic() + timeout_secs
+    while True:
+        combined = "".join(stdout + stderr)
+        launched = re.search(r"Launched as ID (\d+)", combined)
+        returncode = process.poll()
+        if launched is not None:
+            launched_id = int(launched.group(1))
+            if returncode is None or returncode in (0, launched_id):
+                return controller
+        if returncode is not None:
+            controller.close()
+            detail = "".join(controller.output()).strip()[-2000:] or "unknown error"
+            raise RenderDocError(f"RenderDoc exited with code {returncode}: {detail}")
+        if time.monotonic() >= deadline:
+            controller.close()
+            detail = "".join(controller.output()).strip()[-2000:]
+            suffix = f": {detail}" if detail else ""
+            raise RenderDocError(
+                f"RenderDoc command timed out waiting for {arguments[0]} readiness after "
+                f"{timeout_secs}s{suffix}"
+            )
+        time.sleep(0.01)
+
+
 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")
@@ -115,23 +191,33 @@ def capture_program(
     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,
-        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, focused, captures = _wait_for_triggered_capture(
-            output.parent,
-            before,
-            process_name,
-            visible_before_launch,
-            capture_wait_secs,
+        controller = _start_capture_controller(
+            cli_args,
+            timeout_secs=timeout_secs,
+            command=command,
         )
+        try:
+            time.sleep(max(0.0, trigger_after_secs))
+            target_pid, focused, captures = _wait_for_triggered_capture(
+                output.parent,
+                before,
+                process_name,
+                visible_before_launch,
+                capture_wait_secs,
+            )
+        finally:
+            controller.close()
+        stdout, stderr = controller.output()
     else:
+        result = _run(
+            cli_args,
+            timeout_secs=timeout_secs,
+            command=command,
+            accept_launched_id=not effective_wait_for_exit,
+        )
+        stdout, stderr = result.stdout, result.stderr
         focused = False
         captures = _new_captures(output.parent, before)
     injection_error: Optional[str] = None
@@ -157,9 +243,7 @@ def capture_program(
         except RenderDocError as exc:
             injection_error = str(exc)
     if not captures:
-        output_detail = "\n".join(
-            part.strip() for part in (result.stdout, result.stderr) if part.strip()
-        )[-2000:]
+        output_detail = "\n".join(part.strip() for part in (stdout, stderr) if part.strip())[-2000:]
         diagnostics = _capture_failure_diagnostics(
             process_id=target_pid,
             process_name=trigger_process_name or target.name,
@@ -175,7 +259,7 @@ def capture_program(
         "target": str(target),
         "captures": [str(path) for path in captures],
         "focused_target_window": focused,
-        "stdout": result.stdout.strip(),
+        "stdout": stdout.strip(),
     }
 
 
@@ -204,34 +288,36 @@ def capture_process(
         cli_args.extend(["--working-dir", str(cwd)])
     if api_validation:
         cli_args.append("--opt-api-validation")
-    result = _run(
+    controller = _start_capture_controller(
         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)
+    try:
+        time.sleep(max(0.0, trigger_after_secs))
+        focused = _trigger_capture_hotkey(process_id)
+        captures = _wait_for_captures(output.parent, before, capture_wait_secs)
+    finally:
+        controller.close()
+    stdout, stderr = controller.output()
     if not captures:
-        output_detail = "\n".join(
-            part.strip() for part in (result.stdout, result.stderr) if part.strip()
-        )[-2000:]
+        output_detail = "\n".join(part.strip() for part in (stdout, 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}. "
+            "No .rdc capture appeared after injection and F12. Inject before the target creates "
+            "its graphics device; for an already initialized game, relaunch it with "
+            f"capture_program. {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(),
+        "stdout": stdout.strip(),
     }
 
 

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.2}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/SKILL.md

@@ -27,4 +27,6 @@ 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.
+and waits for the resulting capture. Inject before the target creates its graphics device; late
+injection cannot recover resources that RenderDoc did not observe. Prefer `capture_program` when
+the executable can be launched directly. Neither tool terminates the target process.

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.2}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/tools.yaml

@@ -46,7 +46,7 @@ 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.
+    description: Inject RenderDoc into one Windows process before it creates its graphics device, focus its visible window, trigger F12 after a delay, and return the new .rdc file. Use when a game must be launched by its platform client. Prefer capture_program for an already initialized game; not for hidden services or process termination.
     input_schema:
       type: object
       required: [process_id, output_template]

{dcc_mcp_renderdoc-0.3.1 → dcc_mcp_renderdoc-0.3.2}/tests/test_runtime.py

@@ -1,11 +1,24 @@
+import io
 from pathlib import Path
-from subprocess import CompletedProcess
+from subprocess import CompletedProcess, TimeoutExpired
 
 import pytest
 
 from dcc_mcp_renderdoc import runtime
 
 
+class StubController:
+    def __init__(self, stdout="Launched as ID 123", stderr=""):
+        self.stdout = stdout
+        self.stderr = stderr
+
+    def output(self):
+        return self.stdout, self.stderr
+
+    def close(self):
+        return None
+
+
 def test_parse_capture_xml_summarizes_stable_fields(tmp_path: Path):
     xml_file = tmp_path / "capture.xml"
     xml_file.write_text(
@@ -76,10 +89,9 @@ def test_capture_process_injects_triggers_and_reports_capture(tmp_path, monkeypa
 
     def fake_run(arguments, **kwargs):
         observed["arguments"] = arguments
-        observed["accept_launched_id"] = kwargs["accept_launched_id"]
-        return CompletedProcess(arguments, 456, "Launched as ID 456", "")
+        return StubController("Launched as ID 456")
 
-    monkeypatch.setattr(runtime, "_run", fake_run)
+    monkeypatch.setattr(runtime, "_start_capture_controller", fake_run)
     monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda pid: pid == 42)
     monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
     monkeypatch.setattr(
@@ -91,18 +103,168 @@ def test_capture_process_injects_triggers_and_reports_capture(tmp_path, monkeypa
     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_process_triggers_while_injector_is_running_and_only_stops_injector(
+    tmp_path, monkeypatch
+):
+    started = {}
+    target = {"running": True}
+    command = tmp_path / "renderdoccmd.exe"
+    command.touch()
+
+    class Injector:
+        def __init__(self, arguments, **kwargs):
+            started.update(arguments=arguments, kwargs=kwargs, process=self)
+            self.stdout = io.StringIO("Launched as ID 42\n")
+            self.stderr = io.StringIO("")
+            self.returncode = None
+            self.terminated = False
+            self.killed = False
+
+        def poll(self):
+            return self.returncode
+
+        def terminate(self):
+            self.terminated = True
+            self.returncode = 0
+
+        def kill(self):
+            self.killed = True
+            self.returncode = -9
+
+        def wait(self, timeout=None):
+            if self.returncode is None:
+                raise TimeoutExpired(self.args, timeout)
+            return self.returncode
+
+    monkeypatch.setattr(runtime.subprocess, "Popen", Injector)
+    monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda process_id: process_id == 42)
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_captures",
+        lambda directory, before, timeout: [tmp_path / "capture_frame1.rdc"],
+    )
+
+    result = runtime.capture_process(
+        42,
+        str(tmp_path / "capture;still-one-argument"),
+        trigger_after_secs=0,
+        timeout_secs=1,
+        command=str(command),
+    )
+
+    assert result["focused_target_window"] is True
+    assert started["arguments"][1:3] == ["inject", "--PID=42"]
+    assert started["arguments"][4] == str((tmp_path / "capture;still-one-argument").resolve())
+    assert started["kwargs"]["shell"] is False
+    assert started["process"].terminated is True
+    assert started["process"].killed is False
+    assert target["running"] is True
+
+
+def test_capture_process_readiness_timeout_force_stops_only_injector(tmp_path, monkeypatch):
+    command = tmp_path / "renderdoccmd.exe"
+    command.touch()
+    target = {"running": True}
+    started = {}
+
+    class StuckInjector:
+        def __init__(self, arguments, **kwargs):
+            started["process"] = self
+            self.stdout = io.StringIO("")
+            self.stderr = io.StringIO("")
+            self.killed = False
+            self.terminated = False
+
+        def poll(self):
+            return -9 if self.killed else None
+
+        def terminate(self):
+            self.terminated = True
+
+        def kill(self):
+            self.killed = True
+
+        def wait(self, timeout=None):
+            if not self.killed:
+                raise TimeoutExpired("renderdoccmd", timeout)
+            return -9
+
+    monkeypatch.setattr(runtime.subprocess, "Popen", StuckInjector)
+
+    with pytest.raises(runtime.RenderDocError, match="waiting for inject readiness"):
+        runtime.capture_process(
+            42,
+            str(tmp_path / "capture"),
+            trigger_after_secs=0,
+            timeout_secs=0,
+            command=str(command),
+        )
+
+    assert started["process"].terminated is True
+    assert started["process"].killed is True
+    assert target["running"] is True
+
+
+def test_triggered_program_capture_keeps_controller_alive_until_capture(tmp_path, monkeypatch):
+    target = tmp_path / "game.exe"
+    target.touch()
+    command = tmp_path / "renderdoccmd.exe"
+    command.touch()
+    events = []
+
+    class Controller:
+        def __init__(self, arguments, **kwargs):
+            events.append(("started", arguments, kwargs))
+            self.stdout = io.StringIO("Launched as ID 77\n")
+            self.stderr = io.StringIO("")
+            self.returncode = None
+
+        def poll(self):
+            return self.returncode
+
+        def terminate(self):
+            events.append(("stopped",))
+            self.returncode = 0
+
+        def kill(self):
+            raise AssertionError("responsive controller should not be killed")
+
+        def wait(self, timeout=None):
+            return self.returncode
+
+    monkeypatch.setattr(runtime.subprocess, "Popen", Controller)
+    monkeypatch.setattr(runtime, "_visible_process_ids", lambda _name: [])
+
+    def captured_while_running(directory, before, name, ignored, timeout):
+        assert [event[0] for event in events] == ["started"]
+        return 77, True, [tmp_path / "capture_frame1.rdc"]
+
+    monkeypatch.setattr(runtime, "_wait_for_triggered_capture", captured_while_running)
+
+    result = runtime.capture_program(
+        str(target),
+        str(tmp_path / "capture"),
+        trigger_after_secs=0,
+        command=str(command),
+    )
+
+    assert result["captures"] == [str((tmp_path / "capture_frame1.rdc").resolve())]
+    assert [event[0] for event in events] == ["started", "stopped"]
+    assert events[0][1][-1] == str(target.resolve())
+    assert events[0][2]["shell"] is False
+
+
 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", ""),
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
     )
     monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
     monkeypatch.setattr(
@@ -131,8 +293,8 @@ def test_capture_program_failure_reports_missing_child_diagnostics(tmp_path, mon
     target.touch()
     monkeypatch.setattr(
         runtime,
-        "_run",
-        lambda arguments, **kwargs: CompletedProcess(arguments, 123, "Launched as ID 123", ""),
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
     )
     monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
     monkeypatch.setattr(
@@ -203,8 +365,8 @@ def test_capture_program_injects_visible_unhooked_child(tmp_path, monkeypatch):
     observed = {}
     monkeypatch.setattr(
         runtime,
-        "_run",
-        lambda arguments, **kwargs: CompletedProcess(arguments, 123, "Launched as ID 123", ""),
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
     )
     monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
     monkeypatch.setattr(
@@ -239,10 +401,8 @@ def test_capture_program_injects_visible_unhooked_child(tmp_path, monkeypatch):
 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"
-        ),
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController("Launched as ID 42", "inject warning"),
     )
     monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
     monkeypatch.setattr(runtime, "_trigger_capture_hotkey", lambda pid: False)
@@ -257,6 +417,8 @@ def test_capture_process_failure_reports_injection_diagnostics(tmp_path, monkeyp
         runtime.capture_process(42, str(tmp_path / "capture"))
 
     message = str(error.value)
+    assert "before the target creates its graphics device" in message
+    assert "capture_program" in message
     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

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

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

dcc_mcp_renderdoc-0.3.1/src/dcc_mcp_renderdoc/__version__.py

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