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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcc-mcp-renderdoc
-Version: 0.3.0
+Version: 0.3.1
 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.1}/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.1}/pyproject.toml

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

dcc_mcp_renderdoc-0.3.1/src/dcc_mcp_renderdoc/__version__.py

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

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

@@ -102,6 +102,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:
@@ -120,15 +124,38 @@ def capture_program(
     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),
+        target_pid, focused, captures = _wait_for_triggered_capture(
+            output.parent,
+            before,
+            process_name,
+            visible_before_launch,
+            capture_wait_secs,
         )
-        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)
+    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()
@@ -142,6 +169,7 @@ 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),
@@ -246,32 +274,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.1}/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}

{dcc_mcp_renderdoc-0.3.0 → dcc_mcp_renderdoc-0.3.1}/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.0 → dcc_mcp_renderdoc-0.3.1}/tests/test_runtime.py

@@ -105,16 +105,14 @@ def test_capture_program_focuses_requested_child_before_trigger(tmp_path, monkey
         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"],
+        "_wait_for_triggered_capture",
+        lambda directory, before, name, ignored, timeout: (
+            observed.setdefault("pid", 77),
+            True,
+            [tmp_path / "capture_frame1.rdc"],
+        ),
     )
 
     result = runtime.capture_program(
@@ -137,9 +135,11 @@ def test_capture_program_failure_reports_missing_child_diagnostics(tmp_path, mon
         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,
+        "_wait_for_triggered_capture",
+        lambda directory, before, name, ignored, timeout: (None, False, []),
+    )
     monkeypatch.setattr(
         runtime,
         "_visible_processes",
@@ -161,6 +161,81 @@ def test_capture_program_failure_reports_missing_child_diagnostics(tmp_path, mon
     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,
+        "_run",
+        lambda arguments, **kwargs: CompletedProcess(arguments, 123, "Launched as ID 123", ""),
+    )
+    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,

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