dcc-mcp-renderdoc 0.3.0__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.0 → dcc_mcp_renderdoc-0.3.2}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # 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)
+
+
+### Bug Fixes
+
+* allow long-running frame trigger delays ([#10](https://github.com/dcc-mcp/dcc-mcp-renderdoc/issues/10)) ([3212cf7](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/3212cf7c9f236b28b48bf0d28705e2b1939fbe21))
+* capture relaunched child processes ([39e5603](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/39e5603112c8cad98807da3fee86248dd03fb824))
+
+
+### Documentation
+
+* align agent workflow and branding ([ca8b2cf](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/ca8b2cf955a470a87efde24c12e9ebbdb284633c))
+* document CLI install and updates ([599cc70](https://github.com/dcc-mcp/dcc-mcp-renderdoc/commit/599cc70445e11c2fc53d2626c24f9912365b87e0))
+
 ## [0.3.0](https://github.com/dcc-mcp/dcc-mcp-renderdoc/compare/v0.2.1...v0.3.0) (2026-07-16)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcc-mcp-renderdoc
-Version: 0.3.0
+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
@@ -28,6 +28,53 @@ Description-Content-Type: text/markdown
 
 # dcc-mcp-renderdoc
 
+<p align="center">
+  <img src="docs/assets/dcc-mcp-renderdoc.svg" alt="DCC-MCP · RENDERDOC" width="600">
+</p>
+
+## Agent workflow
+
+AI agents should use the shared gateway through `dcc-mcp-cli`; IDE users may
+continue to use the MCP endpoint. Prefer typed skills and tools over raw scripts.
+
+### Install or update the CLI
+
+`dcc-mcp-cli` is the preferred control path for every shell-capable agent. If
+it is missing, ask the user before installing the latest official release:
+
+```bash
+# Linux/macOS
+curl -fsSL https://raw.githubusercontent.com/dcc-mcp/dcc-mcp-core/main/scripts/install-cli.sh | sh
+
+# Windows PowerShell
+powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/dcc-mcp/dcc-mcp-core/main/scripts/install-cli.ps1 | iex"
+```
+
+Keep an official build current through the release manifest:
+
+```bash
+dcc-mcp-cli update check
+dcc-mcp-cli update apply
+```
+
+`update apply` downloads and stages the latest CLI for the next launch. It
+does not update a running `dcc-mcp-server`; update that server in its own
+environment.
+
+```bash
+dcc-mcp-cli dcc-types
+dcc-mcp-cli list
+dcc-mcp-cli search --query "<task>" --dcc-type renderdoc
+dcc-mcp-cli describe <tool-slug>
+dcc-mcp-cli call <tool-slug> --json '{"key":"value"}'
+```
+
+`dcc-types` reports release-catalog support; `list` reports live sessions. If a
+tool belongs to an inactive progressive skill, call `dcc-mcp-cli load-skill <skill-name> --dcc-type renderdoc` before retrying. For post-task improvement,
+attach a stable session id with `--meta-json`, query `dcc-mcp-cli stats --range 24h --session-id <task-id>`, then pass the bounded evidence to the
+`review_skill_improvement` prompt from `dcc-mcp-skills-creator`.
+
+
 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

{dcc_mcp_renderdoc-0.3.0 → dcc_mcp_renderdoc-0.3.2}/README.md

@@ -1,5 +1,52 @@
 # dcc-mcp-renderdoc
 
+<p align="center">
+  <img src="docs/assets/dcc-mcp-renderdoc.svg" alt="DCC-MCP · RENDERDOC" width="600">
+</p>
+
+## Agent workflow
+
+AI agents should use the shared gateway through `dcc-mcp-cli`; IDE users may
+continue to use the MCP endpoint. Prefer typed skills and tools over raw scripts.
+
+### Install or update the CLI
+
+`dcc-mcp-cli` is the preferred control path for every shell-capable agent. If
+it is missing, ask the user before installing the latest official release:
+
+```bash
+# Linux/macOS
+curl -fsSL https://raw.githubusercontent.com/dcc-mcp/dcc-mcp-core/main/scripts/install-cli.sh | sh
+
+# Windows PowerShell
+powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/dcc-mcp/dcc-mcp-core/main/scripts/install-cli.ps1 | iex"
+```
+
+Keep an official build current through the release manifest:
+
+```bash
+dcc-mcp-cli update check
+dcc-mcp-cli update apply
+```
+
+`update apply` downloads and stages the latest CLI for the next launch. It
+does not update a running `dcc-mcp-server`; update that server in its own
+environment.
+
+```bash
+dcc-mcp-cli dcc-types
+dcc-mcp-cli list
+dcc-mcp-cli search --query "<task>" --dcc-type renderdoc
+dcc-mcp-cli describe <tool-slug>
+dcc-mcp-cli call <tool-slug> --json '{"key":"value"}'
+```
+
+`dcc-types` reports release-catalog support; `list` reports live sessions. If a
+tool belongs to an inactive progressive skill, call `dcc-mcp-cli load-skill <skill-name> --dcc-type renderdoc` before retrying. For post-task improvement,
+attach a stable session id with `--meta-json`, query `dcc-mcp-cli stats --range 24h --session-id <task-id>`, then pass the bounded evidence to the
+`review_skill_improvement` prompt from `dcc-mcp-skills-creator`.
+
+
 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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dcc-mcp-renderdoc"
-version = "0.3.0"
+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.0 → 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")
@@ -102,6 +178,10 @@ def capture_program(
         raise RenderDocError(f"Working directory does not exist: {cwd}")
 
     before = {path.resolve() for path in output.parent.glob("*.rdc")}
+    process_name = trigger_process_name or target.name
+    visible_before_launch = (
+        set(_visible_process_ids(process_name)) if trigger_after_secs is not None else set()
+    )
     cli_args = ["capture", "--working-dir", str(cwd), "--capture-file", str(output)]
     effective_wait_for_exit = wait_for_exit and trigger_after_secs is None
     if effective_wait_for_exit:
@@ -111,28 +191,59 @@ 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 = _wait_for_visible_process(
-            trigger_process_name or target.name,
-            min(capture_wait_secs, 30),
+        controller = _start_capture_controller(
+            cli_args,
+            timeout_secs=timeout_secs,
+            command=command,
         )
-        focused = _trigger_capture_hotkey(target_pid)
-        captures = _wait_for_captures(output.parent, before, capture_wait_secs)
+        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
+    if (
+        not captures
+        and target_pid is not None
+        and hook_children
+        and trigger_process_name is not None
+    ):
+        try:
+            fallback = capture_process(
+                target_pid,
+                output_template,
+                working_directory=str(cwd),
+                trigger_after_secs=0.25,
+                capture_wait_secs=capture_wait_secs,
+                api_validation=api_validation,
+                timeout_secs=min(timeout_secs, 60),
+                command=command,
+            )
+            captures = [Path(path).resolve() for path in fallback["captures"]]
+            focused = bool(fallback["focused_target_window"]) or focused
+        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,
@@ -142,12 +253,13 @@ def capture_program(
             "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}"
+            + (f". Injection fallback: {injection_error}" if injection_error else "")
         )
     return {
         "target": str(target),
         "captures": [str(path) for path in captures],
         "focused_target_window": focused,
-        "stdout": result.stdout.strip(),
+        "stdout": stdout.strip(),
     }
 
 
@@ -176,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(),
     }
 
 
@@ -246,32 +360,47 @@ def _trigger_capture_hotkey(process_id: Optional[int] = None) -> bool:
             return True
 
         user32.EnumWindows(find_window, 0)
-        if target:
-            user32.SetForegroundWindow(target)
-            time.sleep(0.15)
+        if not target:
+            return False
+        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
+def _wait_for_triggered_capture(
+    directory: Path,
+    before: set[Path],
+    process_name: str,
+    ignored_process_ids: set[int],
+    timeout_secs: int,
+) -> tuple[Optional[int], bool, list[Path]]:
     deadline = time.monotonic() + timeout_secs
+    handled_process_ids = set(ignored_process_ids)
+    target_pid: Optional[int] = None
+    focused = False
     while time.monotonic() < deadline:
-        process_id = _visible_process_id(process_name)
-        if process_id is not None:
-            return process_id
+        captures = _new_captures(directory, before)
+        if captures:
+            return target_pid, focused, captures
+        for process_id in _visible_process_ids(process_name):
+            if process_id in handled_process_ids:
+                continue
+            handled_process_ids.add(process_id)
+            target_pid = process_id
+            focused = _trigger_capture_hotkey(process_id) or focused
         time.sleep(0.25)
-    return None
+    return target_pid, focused, _new_captures(directory, before)
 
 
-def _visible_process_id(process_name: str) -> Optional[int]:
+def _visible_process_ids(process_name: str) -> list[int]:
     expected = Path(process_name).name.casefold()
-    for process in _visible_processes():
-        if process["name"].casefold() == expected:
-            return int(process["process_id"])
-    return None
+    return [
+        int(process["process_id"])
+        for process in _visible_processes()
+        if process["name"].casefold() == expected
+    ]
 
 
 def _visible_processes(limit: int = 64) -> list[dict[str, Any]]:

{dcc_mcp_renderdoc-0.3.0 → 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.0 → dcc_mcp_renderdoc-0.3.2}/src/dcc_mcp_renderdoc/skills/renderdoc-capture/tools.yaml

@@ -29,7 +29,7 @@ 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_after_secs: {type: number, minimum: 0, maximum: 900}
         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}
@@ -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.0 → dcc_mcp_renderdoc-0.3.2}/tests/test_package.py

@@ -24,6 +24,22 @@ def test_bundled_skills_and_release_workflow_exist():
     assert (root / ".github" / "workflows" / "release.yml").is_file()
 
 
+def test_capture_program_accepts_ten_minute_boss_trigger():
+    root = Path(__file__).parents[1]
+    tools = (
+        root / "src" / "dcc_mcp_renderdoc" / "skills" / "renderdoc-capture" / "tools.yaml"
+    ).read_text(encoding="utf-8")
+    capture_program = re.search(
+        r"  - name: capture_program(?P<body>.*?)(?=\n  - name:)", tools, re.DOTALL
+    )
+    assert capture_program is not None
+    maximum = re.search(
+        r"trigger_after_secs: \{[^}]*maximum: (?P<seconds>\d+)", capture_program.group("body")
+    )
+    assert maximum is not None
+    assert int(maximum.group("seconds")) >= 612
+
+
 def test_runtime_version_matches_distribution_metadata():
     root = Path(__file__).parents[1]
     pyproject = (root / "pyproject.toml").read_text(encoding="utf-8")

dcc_mcp_renderdoc-0.3.2/tests/test_runtime.py

@@ -0,0 +1,429 @@
+import io
+from pathlib import Path
+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(
+        """<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
+        return StubController("Launched as ID 456")
+
+    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(
+        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 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,
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_triggered_capture",
+        lambda directory, before, name, ignored, timeout: (
+            observed.setdefault("pid", 77),
+            True,
+            [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,
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_triggered_capture",
+        lambda directory, before, name, ignored, timeout: (None, False, []),
+    )
+    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_triggered_capture_retargets_replacement_process(tmp_path, monkeypatch):
+    capture = tmp_path / "capture_frame1.rdc"
+    process_snapshots = iter([[77], [77, 88]])
+    triggered = []
+    monkeypatch.setattr(
+        runtime,
+        "_visible_process_ids",
+        lambda _name: next(process_snapshots, [88]),
+    )
+    monkeypatch.setattr(
+        runtime,
+        "_trigger_capture_hotkey",
+        lambda process_id: not triggered.append(process_id),
+    )
+    monkeypatch.setattr(
+        runtime,
+        "_new_captures",
+        lambda _directory, _before: [capture] if triggered == [77, 88] else [],
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+
+    target_pid, focused, captures = runtime._wait_for_triggered_capture(
+        tmp_path,
+        set(),
+        "game.exe",
+        set(),
+        1,
+    )
+
+    assert triggered == [77, 88]
+    assert target_pid == 88
+    assert focused is True
+    assert captures == [capture]
+
+
+def test_capture_program_injects_visible_unhooked_child(tmp_path, monkeypatch):
+    target = tmp_path / "launcher.exe"
+    target.touch()
+    capture = tmp_path / "capture_frame1.rdc"
+    observed = {}
+    monkeypatch.setattr(
+        runtime,
+        "_start_capture_controller",
+        lambda arguments, **kwargs: StubController(),
+    )
+    monkeypatch.setattr(runtime.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        runtime,
+        "_wait_for_triggered_capture",
+        lambda directory, before, name, ignored, timeout: (88, True, []),
+    )
+
+    def fake_capture_process(process_id, output_template, **kwargs):
+        observed.update(process_id=process_id, output_template=output_template, **kwargs)
+        return {
+            "captures": [str(capture)],
+            "focused_target_window": True,
+            "stdout": "injected",
+        }
+
+    monkeypatch.setattr(runtime, "capture_process", fake_capture_process)
+
+    result = runtime.capture_program(
+        str(target),
+        str(tmp_path / "capture"),
+        hook_children=True,
+        trigger_after_secs=1,
+        trigger_process_name="game.exe",
+    )
+
+    assert observed["process_id"] == 88
+    assert observed["trigger_after_secs"] == 0.25
+    assert result["captures"] == [str(capture.resolve())]
+
+
+def test_capture_process_failure_reports_injection_diagnostics(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        runtime,
+        "_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)
+    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 "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
+
+
+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.3.0/.release-please-manifest.json

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

dcc_mcp_renderdoc-0.3.0/src/dcc_mcp_renderdoc/__version__.py

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

dcc_mcp_renderdoc-0.3.0/tests/test_runtime.py

@@ -1,192 +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_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"))