davinci-resolve-mcp 2.32.1 → 2.33.0

package/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.33.0
+
+Fusion node-graph layout and duplication, plus performance and robustness
+improvements across the compound server. Live-validated on DaVinci Resolve
+Studio 21.0.0.
+
+### Fusion node layout & duplication
+
+- **Added** `fusion_comp(action="get_position")` and `set_position` — read and
+  write a node's position on the FlowView canvas. `set_position` confirms the
+  move by reading the position back.
+- **Added** `fusion_comp(action="copy_tool")` — duplicate a node, optionally
+  renaming and repositioning it. Settings are carried through a temporary
+  `.setting` file, which round-trips reliably across the Python bridge where the
+  in-memory `SaveSettings()`/`Paste()` table form fails.
+- **Added** `fusion_comp(action="auto_arrange")` — lay tools out in a row
+  (`direction="horizontal"`) or column (`"vertical"`) at a given spacing.
+
+### Performance
+
+- **Changed** Resolve object inspection walks `dir(obj)` once instead of once for
+  methods and again for properties, skips `inspect.signature()` for C-extension
+  methods (slow and almost always raising there), and reads `__doc__` directly.
+  Each attribute access on a Resolve object is a bridge round-trip, so this
+  roughly halves inspection cost on the `resolve_control` path.
+- **Changed** Media-pool find-by-name lookups walk the folder tree lazily and
+  stop at the first match instead of materializing the entire project tree.
+
+### Robustness & fixes
+
+- **Fixed** `export_frame_as_still` rejects an empty path or a nonexistent target
+  directory instead of silently returning failure.
+- **Fixed** `set_mark_in_out` (clip and timeline) rejects `mark_in > mark_out`.
+- **Fixed** Auto-sync audio resolves `AUDIO_SYNC_*` enum constants via the live
+  Resolve handle, closing a path where a stale module handle silently degraded
+  `AutoSyncAudio` to rejected string keys.
+- **Changed** Every `subprocess` call that can run while the MCP stdio server is
+  active now sets `stdin=subprocess.DEVNULL`, so a child process cannot consume
+  bytes from the JSON-RPC protocol stream; the spec-hook runner also captures its
+  child's output. Applies to both the compound and granular launchers.
+
+## What's New in v2.32.2
+
+Fixes `fusion_comp(action="get_keyframes")` serialization.
+
+The handler iterated `Input.GetKeyFrames()` as if it returned `{time: value}`,
+but Fusion returns `{1-based index: frame_position}`. The result put the
+keyframe **index** in `time` and the **frame position** in `value` — the actual
+keyframed values were never reported.
+
+The handler now treats the dict values as frame positions and reads each
+keyframed value back via `GetInput(input_name, frame)`.
+
+- **Fixed** `get_keyframes` now returns `[{"time": <frame>, "value": <value>}, ...]`
+  in frame order (live-validated on DaVinci Resolve Studio 21.0.0:
+  `Size` keyed `1.0@f0` / `1.4@f75` → `[{0.0: 1.0}, {75.0: 1.4}]`).
+- Follow-up to the `add_keyframe` fix in v2.32.1; flagged by @sandypoli-boop in #56.
+
 ## What's New in v2.32.1
 
 Fixes `fusion_comp(action="add_keyframe")` so it actually **animates** the input.

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.32.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.33.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-32%20(341%20full)-blue.svg)](#server-modes)

package/docs/SKILL.md

@@ -979,6 +979,12 @@ Key actions:
 - `get_inputs(tool_name)` / `get_outputs(tool_name)`
 - `set_attrs(tool_name, attrs)` / `get_attrs(tool_name)`
 - `add_keyframe(tool_name, input_name, time, value)`
+- `get_position(tool_name)` / `set_position(tool_name, x, y)` — read/write a node's
+  position on the FlowView canvas; `set_position` returns a position read-back
+- `copy_tool(tool_name, name?, x?, y?)` — duplicate a node (settings copied via a
+  temp `.setting` file), optionally renaming and repositioning it
+- `auto_arrange(tool_names?, direction?, spacing?, x?, y?)` — lay tools out in a row
+  (`direction="horizontal"`, default) or column (`"vertical"`)
 - `get_comp_info`, `set_frame_range(start, end)`, `render`
 - `start_undo(name?)` / `end_undo(keep?)`
 - `bulk_set_inputs(ops)` — batch set inputs across multiple timeline item comps in

package/install.py

@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.32.1"
+VERSION = "2.33.0"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.32.1",
+  "version": "2.33.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.32.1"
+VERSION = "2.33.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")
@@ -330,17 +330,17 @@ def _launch_resolve():
         app_path = "/Applications/DaVinci Resolve/DaVinci Resolve.app"
         if not os.path.exists(app_path):
             return False
-        subprocess.Popen(["open", app_path])
+        subprocess.Popen(["open", app_path], stdin=subprocess.DEVNULL)
     elif sys_name == "windows":
         app_path = r"C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe"
         if not os.path.exists(app_path):
             return False
-        subprocess.Popen([app_path])
+        subprocess.Popen([app_path], stdin=subprocess.DEVNULL)
     elif sys_name == "linux":
         app_path = "/opt/resolve/bin/resolve"
         if not os.path.exists(app_path):
             return False
-        subprocess.Popen([app_path])
+        subprocess.Popen([app_path], stdin=subprocess.DEVNULL)
     else:
         return False
     logger.info("Launched DaVinci Resolve, waiting for it to respond...")
@@ -380,22 +380,36 @@ def get_current_project():
     proj = pm.GetCurrentProject()
     return pm, proj
 
-def get_all_media_pool_clips(media_pool):
-    """Get all clips from media pool recursively including subfolders."""
-    clips = []
+def iter_all_media_pool_clips(media_pool):
+    """Yield every clip in the media pool, walking subfolders lazily.
+
+    Unlike get_all_media_pool_clips(), this does not materialize the whole tree.
+    A caller that breaks early (e.g. find-by-name) stops the walk as soon as it
+    has a match, avoiding a full traversal. Each folder access is a Resolve
+    bridge round-trip, so early exit is a real win on large projects.
+
+    Yields in the same pre-order (parent clips before descendants, siblings in
+    listed order) as the eager get_all_media_pool_clips().
+    """
     root_folder = media_pool.GetRootFolder()
-    
-    def process_folder(folder):
+    if not root_folder:
+        return
+    stack = [root_folder]
+    while stack:
+        folder = stack.pop()
         folder_clips = folder.GetClipList()
         if folder_clips:
-            clips.extend(folder_clips)
-        
+            for clip in folder_clips:
+                yield clip
         sub_folders = folder.GetSubFolderList()
-        for sub_folder in sub_folders:
-            process_folder(sub_folder)
-    
-    process_folder(root_folder)
-    return clips
+        if sub_folders:
+            # Reversed so the LIFO stack pops siblings in their listed order.
+            stack.extend(reversed(list(sub_folders)))
+
+
+def get_all_media_pool_clips(media_pool):
+    """Get all clips from media pool recursively including subfolders."""
+    return list(iter_all_media_pool_clips(media_pool))
 
 def get_all_media_pool_folders(media_pool):
     """Get all folders from media pool recursively."""

package/src/granular/media_pool_item.py

@@ -53,10 +53,10 @@ def link_proxy_media(clip_name: str, proxy_file_path: str) -> str:
     if not media_pool:
         return "Error: Failed to get Media Pool"
     
-    # Find the clip by name
-    clips = get_all_media_pool_clips(media_pool)
+    # Find the clip by name (lazy walk; stops at the first match)
+    clips = iter_all_media_pool_clips(media_pool)
     target_clip = None
-    
+
     for clip in clips:
         if clip.GetName() == clip_name:
             target_clip = clip
@@ -94,10 +94,10 @@ def unlink_proxy_media(clip_name: str) -> str:
     if not media_pool:
         return "Error: Failed to get Media Pool"
     
-    # Find the clip by name
-    clips = get_all_media_pool_clips(media_pool)
+    # Find the clip by name (lazy walk; stops at the first match)
+    clips = iter_all_media_pool_clips(media_pool)
     target_clip = None
-    
+
     for clip in clips:
         if clip.GetName() == clip_name:
             target_clip = clip
@@ -132,10 +132,10 @@ def replace_clip(clip_name: str, replacement_path: str) -> str:
     if not media_pool:
         return "Error: Failed to get Media Pool"
     
-    # Find the clip by name
-    clips = get_all_media_pool_clips(media_pool)
+    # Find the clip by name (lazy walk; stops at the first match)
+    clips = iter_all_media_pool_clips(media_pool)
     target_clip = None
-    
+
     for clip in clips:
         if clip.GetName() == clip_name:
             target_clip = clip
@@ -181,10 +181,10 @@ def transcribe_audio(clip_name: str, use_speaker_detection: Optional[bool] = Non
     if not media_pool:
         return "Error: Failed to get Media Pool"
     
-    # Find the clip by name
-    clips = get_all_media_pool_clips(media_pool)
+    # Find the clip by name (lazy walk; stops at the first match)
+    clips = iter_all_media_pool_clips(media_pool)
     target_clip = None
-    
+
     for clip in clips:
         if clip.GetName() == clip_name:
             target_clip = clip
@@ -223,10 +223,10 @@ def clear_transcription(clip_name: str) -> str:
     if not media_pool:
         return "Error: Failed to get Media Pool"
     
-    # Find the clip by name
-    clips = get_all_media_pool_clips(media_pool)
+    # Find the clip by name (lazy walk; stops at the first match)
+    clips = iter_all_media_pool_clips(media_pool)
     target_clip = None
-    
+
     for clip in clips:
         if clip.GetName() == clip_name:
             target_clip = clip

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.32.1"
+VERSION = "2.33.0"
 
 import base64
 import os
@@ -559,19 +559,19 @@ def _launch_resolve():
         if not os.path.exists(app_path):
             logger.error(f"DaVinci Resolve not found at {app_path}")
             return False
-        subprocess.Popen(["open", app_path])
+        subprocess.Popen(["open", app_path], stdin=subprocess.DEVNULL)
     elif sys_name == "windows":
         app_path = r"C:\Program Files\Blackmagic Design\DaVinci Resolve\Resolve.exe"
         if not os.path.exists(app_path):
             logger.error(f"DaVinci Resolve not found at {app_path}")
             return False
-        subprocess.Popen([app_path])
+        subprocess.Popen([app_path], stdin=subprocess.DEVNULL)
     elif sys_name == "linux":
         app_path = "/opt/resolve/bin/resolve"
         if not os.path.exists(app_path):
             logger.error(f"DaVinci Resolve not found at {app_path}")
             return False
-        subprocess.Popen([app_path])
+        subprocess.Popen([app_path], stdin=subprocess.DEVNULL)
     else:
         return False
     logger.info("Launched DaVinci Resolve, waiting for it to respond...")
@@ -1058,6 +1058,7 @@ def _activate_resolve_window() -> Dict[str, Any]:
             proc = subprocess.run(
                 ["osascript", "-e", 'tell application "DaVinci Resolve" to activate'],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1071,6 +1072,7 @@ def _activate_resolve_window() -> Dict[str, Any]:
                  "$s = New-Object -ComObject WScript.Shell; "
                  "$null = $s.AppActivate('DaVinci Resolve')"],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1083,6 +1085,7 @@ def _activate_resolve_window() -> Dict[str, Any]:
             proc = subprocess.run(
                 ["wmctrl", "-a", "DaVinci Resolve"],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1093,6 +1096,7 @@ def _activate_resolve_window() -> Dict[str, Any]:
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "windowactivate"],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1124,6 +1128,7 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
             proc = subprocess.run(
                 ["osascript", "-e", script],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1139,6 +1144,7 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
                  "Start-Sleep -Milliseconds 150; "
                  "[System.Windows.Forms.SendKeys]::SendWait('+i')"],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1152,6 +1158,7 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "key", "--window", "%@", "shift+i"],
                 capture_output=True, text=True, timeout=5,
+                stdin=subprocess.DEVNULL,
             )
             return {"sent": proc.returncode == 0, "platform": "linux", "tool": "xdotool", "shortcut": "Shift+I"}
         return {"sent": False, "platform": sys.platform, "note": "no key-send tool found"}
@@ -5407,7 +5414,11 @@ def _safe_auto_sync_audio(mp, p: Dict[str, Any]):
     if err:
         return err
     clips, missing = resolved
-    settings = _normalize_auto_sync_settings(dict(p.get("settings") or {}), resolve)
+    # Use get_resolve() rather than the module global `resolve`, which is None
+    # until populated and can be reset to None by a mid-call reconnect. A None
+    # here makes _normalize_auto_sync_settings fall back to string enum keys,
+    # which AutoSyncAudio silently rejects (returns False).
+    settings = _normalize_auto_sync_settings(dict(p.get("settings") or {}), get_resolve())
     if p.get("dry_run", True):
         return _ok(would_auto_sync=True, clips=_clip_summaries(clips), missing=missing, settings=settings)
     return {"success": bool(mp.AutoSyncAudio(clips, settings)), "count": len(clips), "missing": missing, "settings": settings}
@@ -10897,6 +10908,7 @@ def _pick_dashboard_python(repo_root: str) -> Tuple[str, Optional[str]]:
                 capture_output=True,
                 timeout=5,
                 check=False,
+                stdin=subprocess.DEVNULL,
             )
         except (OSError, subprocess.TimeoutExpired):
             continue
@@ -10956,6 +10968,7 @@ def _port_owner_pid(host: str, port: int) -> Optional[int]:
         result = subprocess.run(
             ["lsof", "-nP", "-iTCP:" + str(port), "-sTCP:LISTEN", "-t"],
             capture_output=True, timeout=3, text=True, check=False,
+            stdin=subprocess.DEVNULL,
         )
     except (OSError, subprocess.TimeoutExpired):
         return None
@@ -12071,7 +12084,14 @@ def _make_spec_hook_runner(timeout: float = 120.0):
 
     def _run(hook) -> bool:
         try:
-            proc = subprocess.run(hook.command, shell=True, timeout=timeout)
+            proc = subprocess.run(
+                hook.command,
+                shell=True,
+                timeout=timeout,
+                stdin=subprocess.DEVNULL,
+                capture_output=True,
+                text=True,
+            )
             return proc.returncode == 0
         except Exception as exc:
             logger.warning("spec hook '%s' failed: %s", hook.name or hook.command, exc)
@@ -12450,7 +12470,13 @@ def project_settings(action: str, params: Optional[Dict[str, Any]] = None) -> Di
         g = proj.GetGallery()
         return {"available": g is not None}
     elif action == "export_frame_as_still":
-        return {"success": bool(proj.ExportCurrentFrameAsStill(p["path"]))}
+        still_path = p.get("path")
+        if not still_path:
+            return _err("export_frame_as_still requires a non-empty 'path'")
+        parent = os.path.dirname(os.path.expanduser(still_path))
+        if parent and not os.path.isdir(parent):
+            return _err(f"export_frame_as_still target directory does not exist: {parent}")
+        return {"success": bool(proj.ExportCurrentFrameAsStill(still_path))}
     elif action == "load_burnin_preset":
         return {"success": bool(proj.LoadBurnInPreset(p["name"]))}
     elif action == "insert_audio":
@@ -13874,6 +13900,8 @@ def media_pool_item(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
     elif action == "get_mark_in_out":
         return _ser(clip.GetMarkInOut())
     elif action == "set_mark_in_out":
+        if p["mark_in"] > p["mark_out"]:
+            return _err(f"mark_in ({p['mark_in']}) must be <= mark_out ({p['mark_out']})")
         return {"success": bool(clip.SetMarkInOut(p["mark_in"], p["mark_out"], p.get("type", "all")))}
     elif action == "clear_mark_in_out":
         return {"success": bool(clip.ClearMarkInOut(p.get("type", "all")))}
@@ -15274,6 +15302,8 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
     elif action == "get_mark_in_out":
         return _ser(tl.GetMarkInOut())
     elif action == "set_mark_in_out":
+        if p["mark_in"] > p["mark_out"]:
+            return _err(f"mark_in ({p['mark_in']}) must be <= mark_out ({p['mark_out']})")
         return {"success": bool(tl.SetMarkInOut(p["mark_in"], p["mark_out"], p.get("type", "all")))}
     elif action == "clear_mark_in_out":
         return {"success": bool(tl.ClearMarkInOut(p.get("type", "all")))}
@@ -18405,6 +18435,71 @@ def _fusion_boundary_report(comp, p: Dict[str, Any]):
 
 
 @mcp.tool()
+def _parse_pos(raw):
+    """Normalize a FlowView position return into (x, y) floats, or None.
+
+    Depending on the bridge, position reads come back as a 1-indexed Lua table,
+    a dict ({1: x, 2: y} / {"x": .., "y": ..}), or an (x, y) tuple/list. Be
+    liberal in what we accept.
+    """
+    if raw is None:
+        return None
+    if isinstance(raw, dict):
+        for ka, kb in ((1, 2), ("1", "2"), ("x", "y"), ("X", "Y")):
+            if ka in raw and kb in raw:
+                try:
+                    return float(raw[ka]), float(raw[kb])
+                except (TypeError, ValueError):
+                    return None
+        vals = list(raw.values())
+        if len(vals) >= 2:
+            try:
+                return float(vals[0]), float(vals[1])
+            except (TypeError, ValueError):
+                return None
+        return None
+    if isinstance(raw, (list, tuple)):
+        if len(raw) >= 2:
+            try:
+                return float(raw[0]), float(raw[1])
+            except (TypeError, ValueError):
+                return None
+        return None
+    # Lua table object with numeric indexing.
+    try:
+        return float(raw[1]), float(raw[2])
+    except Exception:
+        return None
+
+
+def _fusion_flow_view(comp):
+    """Return the comp's FlowView (node-graph canvas), or None if unavailable."""
+    try:
+        cf = comp.CurrentFrame
+        if cf is None:
+            return None
+        return cf.FlowView
+    except Exception:
+        return None
+
+
+def _iter_fusion_tools(comp):
+    """Yield (tool_name, tool) for every tool in the comp."""
+    tools = comp.GetToolList() or {}
+    for idx in tools:
+        t = tools[idx]
+        try:
+            name = t.GetAttrs().get("TOOLS_Name", "")
+        except Exception:
+            name = ""
+        yield name, t
+
+
+def _fusion_tool_names(comp):
+    """Return the set-friendly list of tool names currently in the comp."""
+    return [name for name, _ in _iter_fusion_tools(comp)]
+
+
 def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """Fusion composition node graph operations.
 
@@ -18433,6 +18528,11 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       get_keyframes(tool_name, input_name) -> {keyframes}
       delete_keyframe(tool_name, input_name, time) -> {success}
       get_comp_info() -> {name, tool_count, attrs}
+      get_position(tool_name) -> {tool_name, x, y}  — read a node's FlowView position
+      set_position(tool_name, x, y) -> {success, x, y, readback}  — move a node
+      copy_tool(tool_name, name?, x?, y?) -> {success, new_tool, new_tools}  — duplicate a node
+      auto_arrange(tool_names?, direction?, spacing?, x?, y?) -> {success, arranged, count}
+        Lay tools out in a row (direction="horizontal", default) or column ("vertical").
       set_frame_range(start, end) -> {success}
       render() -> {success}
       start_undo(name?) -> {success}
@@ -18685,11 +18785,17 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         inp = tool[p["input_name"]]
         if not inp:
             return _err(f"Input '{p['input_name']}' not found on tool '{p['tool_name']}'")
+        # GetKeyFrames() returns {1-based index: frame_position}, NOT
+        # {time: value}. Iterating it directly puts the index in `time` and the
+        # frame position in `value`. Read the actual keyframed value back from
+        # the input at each frame position via GetInput.
         keyframes = []
         kfs = inp.GetKeyFrames()
         if kfs:
-            for t in kfs:
-                keyframes.append({"time": t, "value": _ser(kfs[t])})
+            for idx in sorted(kfs):
+                frame = kfs[idx]
+                value = tool.GetInput(p["input_name"], frame)
+                keyframes.append({"time": frame, "value": _ser(value)})
         return {"keyframes": keyframes}
 
     elif action == "delete_keyframe":
@@ -18731,6 +18837,127 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         comp.EndUndo(p.get("keep", True))
         return _ok()
 
+    # --- Node Layout (FlowView) ---
+    elif action == "get_position":
+        tool = comp.FindTool(p["tool_name"])
+        if not tool:
+            return _err(f"Tool '{p['tool_name']}' not found")
+        flow = _fusion_flow_view(comp)
+        if flow is None:
+            return _err("FlowView unavailable on this comp")
+        pos = _parse_pos(flow.GetPosTable(tool))
+        if pos is None:
+            return _err(f"Could not read position for tool '{p['tool_name']}'")
+        return {"tool_name": p["tool_name"], "x": pos[0], "y": pos[1]}
+
+    elif action == "set_position":
+        if "x" not in p or "y" not in p:
+            return _err("set_position requires x and y")
+        tool = comp.FindTool(p["tool_name"])
+        if not tool:
+            return _err(f"Tool '{p['tool_name']}' not found")
+        flow = _fusion_flow_view(comp)
+        if flow is None:
+            return _err("FlowView unavailable on this comp")
+        x, y = float(p["x"]), float(p["y"])
+        comp.Lock()
+        try:
+            flow.SetPos(tool, x, y)
+        finally:
+            comp.Unlock()
+        # SetPos has no reliable return; confirm by reading the position back.
+        pos = _parse_pos(flow.GetPosTable(tool))
+        return {
+            "success": True,
+            "tool_name": p["tool_name"],
+            "x": x,
+            "y": y,
+            "readback": {"x": pos[0], "y": pos[1]} if pos else None,
+        }
+
+    elif action == "copy_tool":
+        src = comp.FindTool(p["tool_name"])
+        if not src:
+            return _err(f"Tool '{p['tool_name']}' not found")
+        regid = src.GetAttrs().get("TOOLS_RegID")
+        if not regid:
+            return _err(f"Could not determine the tool type of '{p['tool_name']}'")
+        # Duplicate by adding a same-type tool and loading the source's settings
+        # through a temp .setting FILE. Passing SaveSettings()'s in-memory table
+        # back into Paste/LoadSettings fails across the Python bridge; a file path
+        # round-trips reliably. New node is found by diffing tool names.
+        before = set(_fusion_tool_names(comp))
+        fd, settings_path = tempfile.mkstemp(suffix=".setting")
+        os.close(fd)
+        new_tool = None
+        comp.Lock()
+        try:
+            if not src.SaveSettings(settings_path):
+                return _err(f"SaveSettings failed for '{p['tool_name']}'")
+            new_tool = comp.AddTool(regid, -32768, -32768)
+            if not new_tool:
+                return _err(f"Failed to create a duplicate of '{p['tool_name']}'")
+            new_tool.LoadSettings(settings_path)
+        finally:
+            comp.Unlock()
+            try:
+                os.remove(settings_path)
+            except OSError:
+                pass
+        new_names = [n for n in _fusion_tool_names(comp) if n not in before]
+        new_name = new_names[0] if new_names else new_tool.GetAttrs().get("TOOLS_Name", "")
+        rename = p.get("name")
+        if rename:
+            comp.Lock()
+            try:
+                new_tool.SetAttrs({"TOOLS_Name": rename})
+            finally:
+                comp.Unlock()
+            new_name = rename
+        if "x" in p and "y" in p:
+            flow = _fusion_flow_view(comp)
+            if flow is not None:
+                comp.Lock()
+                try:
+                    flow.SetPos(new_tool, float(p["x"]), float(p["y"]))
+                finally:
+                    comp.Unlock()
+        return {
+            "success": True,
+            "source": p["tool_name"],
+            "new_tool": new_name,
+            "new_tools": new_names,
+        }
+
+    elif action == "auto_arrange":
+        flow = _fusion_flow_view(comp)
+        if flow is None:
+            return _err("FlowView unavailable on this comp")
+        names = p.get("tool_names")
+        if names:
+            tools = [(n, comp.FindTool(n)) for n in names]
+            tools = [(n, t) for n, t in tools if t]
+        else:
+            tools = list(_iter_fusion_tools(comp))
+        if not tools:
+            return _err("No tools to arrange")
+        direction = (p.get("direction") or "horizontal").strip().lower()
+        spacing = float(p.get("spacing", 2.0))
+        x0, y0 = float(p.get("x", 0.0)), float(p.get("y", 0.0))
+        arranged = []
+        comp.Lock()
+        try:
+            for i, (name, tool) in enumerate(tools):
+                if direction == "vertical":
+                    x, y = x0, y0 + i * spacing
+                else:
+                    x, y = x0 + i * spacing, y0
+                flow.SetPos(tool, x, y)
+                arranged.append({"tool_name": name, "x": x, "y": y})
+        finally:
+            comp.Unlock()
+        return {"success": True, "arranged": arranged, "count": len(arranged)}
+
     return _unknown(action, [
         "add_tool","delete_tool","get_tool_list","find_tool",
         "connect","disconnect","get_inputs","get_outputs",
@@ -18738,6 +18965,7 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         "add_keyframe","get_keyframes","delete_keyframe",
         "get_comp_info","set_frame_range","render",
         "start_undo","end_undo",
+        "get_position","set_position","copy_tool","auto_arrange",
         "bulk_set_inputs",
         "bulk_set_expressions",
         *_FUSION_GROUP_KERNEL_ACTIONS,
@@ -18776,7 +19004,8 @@ def _validate_lua_syntax(source: str) -> Dict[str, Any]:
     luac = None
     for candidate in ("luac", "luac5.1", "luac5.3", "luac5.4"):
         try:
-            subprocess.run([candidate, "-v"], capture_output=True, check=True, timeout=5)
+            subprocess.run([candidate, "-v"], capture_output=True, check=True, timeout=5,
+                           stdin=subprocess.DEVNULL)
             luac = candidate
             break
         except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
@@ -18788,7 +19017,8 @@ def _validate_lua_syntax(source: str) -> Dict[str, Any]:
         f.write(source)
         tmp = f.name
     try:
-        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True, timeout=10)
+        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True, timeout=10,
+                                stdin=subprocess.DEVNULL)
         if result.returncode == 0:
             return {"valid": True, "errors": None, "checker": luac}
         return {"valid": False, "errors": result.stderr.strip() or result.stdout.strip(),
@@ -19346,7 +19576,7 @@ def _execute_python_script(path: str, args: List[str],
     try:
         result = subprocess.run(cmd, env=_python_env_for_resolve(),
                                  capture_output=True, text=True,
-                                 timeout=timeout)
+                                 timeout=timeout, stdin=subprocess.DEVNULL)
     except subprocess.TimeoutExpired as e:
         return _err(f"Script timed out after {timeout}s. "
                     f"Partial stdout: {(e.stdout or '')[:1000]}")

package/src/utils/object_inspection.py

@@ -11,99 +11,111 @@ This module provides functions for inspecting DaVinci Resolve API objects:
 
 import sys
 import inspect
+import logging
 from typing import Any, Dict, List, Optional, Union, Callable
 
+logger = logging.getLogger(__name__)
 
-def get_object_methods(obj: Any) -> Dict[str, Dict[str, Any]]:
+
+def get_object_members(
+    obj: Any,
+    include_methods: bool = True,
+    include_properties: bool = True,
+) -> Dict[str, Any]:
     """
-    Get all methods of a DaVinci Resolve object with their documentation.
-    
+    Inspect a DaVinci Resolve object's methods and/or properties in a single pass.
+
+    DaVinci Resolve API objects are C extensions: every attribute access is a
+    bridge round-trip, so we walk ``dir(obj)`` exactly once and classify each
+    attribute, rather than walking it separately for methods and properties.
+
     Args:
         obj: A DaVinci Resolve API object
-        
+        include_methods: Collect callable attributes
+        include_properties: Collect non-callable attributes
+
     Returns:
-        A dictionary of method names and their details
+        A dict with ``"methods"`` and/or ``"properties"`` keys, or ``{"error": ...}``
     """
     if obj is None:
         return {"error": "Cannot inspect None object"}
-    
-    methods = {}
-    
-    # Get all object attributes
+
+    methods: Dict[str, Dict[str, Any]] = {}
+    properties: Dict[str, Dict[str, Any]] = {}
+
     for attr_name in dir(obj):
         # Skip private/internal attributes
         if attr_name.startswith('_'):
             continue
-            
+
         try:
             attr = getattr(obj, attr_name)
-            
-            # Check if it's a callable method
-            if callable(attr):
-                # Get the method signature if possible
+        except Exception as e:
+            if include_methods:
+                methods[attr_name] = {"error": str(e), "type": "error"}
+            if include_properties:
+                properties[attr_name] = {"error": str(e), "type_category": "error"}
+            continue
+
+        if callable(attr):
+            if not include_methods:
+                continue
+            # Only real Python functions/methods carry an introspectable
+            # signature. Resolve API methods are C extensions where
+            # inspect.signature() is slow and almost always raises, so we skip
+            # the attempt and default to "()" for them.
+            if inspect.isfunction(attr) or inspect.ismethod(attr):
                 try:
                     signature = str(inspect.signature(attr))
                 except (ValueError, TypeError):
                     signature = "()"
-                    
-                # Get the docstring if available
-                doc = inspect.getdoc(attr) or ""
-                
-                methods[attr_name] = {
-                    "signature": signature,
-                    "doc": doc,
-                    "type": "method"
-                }
-        except Exception as e:
+            else:
+                signature = "()"
+
+            # Read __doc__ directly instead of inspect.getdoc() to avoid the
+            # MRO walk for inherited docstrings (irrelevant for C-ext methods).
+            doc = (getattr(attr, "__doc__", "") or "").strip()
+
             methods[attr_name] = {
-                "error": str(e),
-                "type": "error"
+                "signature": signature,
+                "doc": doc,
+                "type": "method",
             }
-    
-    return methods
+        else:
+            if not include_properties:
+                continue
+            properties[attr_name] = {
+                "value": str(attr),
+                "type": type(attr).__name__,
+                "type_category": "property",
+            }
+
+    result: Dict[str, Any] = {}
+    if include_methods:
+        result["methods"] = methods
+    if include_properties:
+        result["properties"] = properties
+    return result
+
+
+def get_object_methods(obj: Any) -> Dict[str, Dict[str, Any]]:
+    """
+    Get all methods of a DaVinci Resolve object with their documentation.
+
+    Thin wrapper over :func:`get_object_members` kept for backwards compatibility.
+    """
+    res = get_object_members(obj, include_methods=True, include_properties=False)
+    return res.get("methods", res)
 
 
 def get_object_properties(obj: Any) -> Dict[str, Dict[str, Any]]:
     """
     Get all properties (non-callable attributes) of a DaVinci Resolve object.
-    
-    Args:
-        obj: A DaVinci Resolve API object
-        
-    Returns:
-        A dictionary of property names and their details
+
+    Thin wrapper over :func:`get_object_members` kept for backwards compatibility.
     """
-    if obj is None:
-        return {"error": "Cannot inspect None object"}
-    
-    properties = {}
-    
-    # Get all object attributes
-    for attr_name in dir(obj):
-        # Skip private/internal attributes
-        if attr_name.startswith('_'):
-            continue
-            
-        try:
-            attr = getattr(obj, attr_name)
-            
-            # Skip if it's a method
-            if callable(attr):
-                continue
-                
-            # Get the property value and type
-            properties[attr_name] = {
-                "value": str(attr),
-                "type": type(attr).__name__,
-                "type_category": "property"
-            }
-        except Exception as e:
-            properties[attr_name] = {
-                "error": str(e),
-                "type_category": "error"
-            }
-    
-    return properties
+    res = get_object_members(obj, include_methods=False, include_properties=True)
+    return res.get("properties", res)
 
 
 def inspect_object(obj: Any, max_depth: int = 1) -> Dict[str, Any]:
@@ -120,12 +132,13 @@ def inspect_object(obj: Any, max_depth: int = 1) -> Dict[str, Any]:
     if obj is None:
         return {"error": "Cannot inspect None object"}
     
+    members = get_object_members(obj)
     result = {
         "type": type(obj).__name__,
-        "methods": get_object_methods(obj),
-        "properties": get_object_properties(obj),
+        "methods": members.get("methods", {}),
+        "properties": members.get("properties", {}),
     }
-    
+
     # Add string representation
     try:
         result["str"] = str(obj)
@@ -252,9 +265,10 @@ def print_object_help(obj: Any) -> str:
         return "Cannot provide help for None object"
     
     obj_type = type(obj).__name__
-    methods = get_object_methods(obj)
-    properties = get_object_properties(obj)
-    
+    members = get_object_members(obj)
+    methods = members.get("methods", {})
+    properties = members.get("properties", {})
+
     help_text = [f"Help for {obj_type} object:"]
     help_text.append("\n" + "=" * 40 + "\n")