@hybridlabor-api/aos 4.3.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/live_fuse_smoke.py

@@ -1,250 +0,0 @@
-"""Live Resolve smoke test for v2.5.0 fuse_plugin authoring.
-
-Installs a curated subset of generated Fuses to the real Fuses directory while
-Resolve is closed, launches Resolve, builds a disposable project with a
-Fusion-composition timeline item, attempts to instantiate each Fuse class via
-comp.AddTool, and reports pass/fail per template.
-
-Cleans up regardless of pass/fail. Quits Resolve afterward unless --keep-open.
-"""
-
-import argparse
-import os
-import subprocess
-import sys
-import time
-
-PROJECT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, PROJECT)
-
-from src.utils.platform import get_resolve_paths, get_resolve_plugin_paths
-
-paths = get_resolve_paths()
-os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
-os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
-sys.path.insert(0, paths["modules_path"])
-
-import DaVinciResolveScript as dvr_script  # noqa: E402
-from src.utils import fuse_templates  # noqa: E402
-
-
-# Curated subset spanning the highest-risk surfaces.
-TEST_TEMPLATES = [
-    ("color_matrix",     {"ops": ["brightness", "contrast"]}),
-    ("text_overlay",     None),
-    ("source_generator", {"kind": "gradient"}),
-    ("transform",        None),
-    ("modifier",         {"kind": "sine"}),
-]
-
-
-def _quit_resolve():
-    try:
-        h = dvr_script.scriptapp("Resolve")
-        if h is not None:
-            h.Quit()
-    except Exception:
-        pass
-
-
-def _add_tool(comp, tool_type):
-    """Locked AddTool — mirrors src/server.py fusion_comp.add_tool."""
-    comp.Lock()
-    try:
-        return comp.AddTool(tool_type, -1, -1)
-    finally:
-        comp.Unlock()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--keep-open", action="store_true",
-                        help="Leave Resolve open with the disposable project after test.")
-    args = parser.parse_args()
-
-    candidate = dvr_script.scriptapp("Resolve")
-    if candidate is not None:
-        try:
-            if candidate.GetVersion():
-                print("ABORT: Resolve is already running. Quit it first.")
-                sys.exit(1)
-        except Exception:
-            pass
-
-    fuses_dir = get_resolve_plugin_paths()["fuses_dir"]
-    os.makedirs(fuses_dir, exist_ok=True)
-
-    print(f"=== Installing {len(TEST_TEMPLATES)} templates ===")
-    installed = []
-    for kind, options in TEST_TEMPLATES:
-        name = "McpLive" + kind.replace("_", "").title()
-        try:
-            source = fuse_templates.TEMPLATES[kind](name, options)
-        except Exception as exc:
-            print(f"  [GEN FAIL] {kind:18s}: {exc}")
-            continue
-        path = os.path.join(fuses_dir, f"{name}.fuse")
-        with open(path, "w", encoding="utf-8") as f:
-            f.write(source)
-        installed.append((kind, name, path))
-        print(f"  [OK]       {kind:18s}: {name}.fuse")
-
-    if not installed:
-        print("ABORT: nothing installed.")
-        sys.exit(1)
-
-    results = []
-    project_created = False
-    pm = None
-
-    try:
-        print("\n=== Launching Resolve ===")
-        if sys.platform != "darwin":
-            print("This harness only supports macOS launch.")
-            sys.exit(1)
-        subprocess.Popen(["open", "/Applications/DaVinci Resolve/DaVinci Resolve.app"])
-
-        handle = None
-        for i in range(60):
-            time.sleep(2)
-            cand = dvr_script.scriptapp("Resolve")
-            if cand is not None:
-                try:
-                    if cand.GetVersion():
-                        handle = cand
-                        print(f"  Connected after {(i+1)*2}s: "
-                              f"{handle.GetProductName()} {handle.GetVersionString()}")
-                        break
-                except Exception:
-                    continue
-        if handle is None:
-            print("ABORT: Resolve did not respond within 120s")
-            sys.exit(1)
-
-        # Build a disposable project + timeline + Fusion-composition clip.
-        # A Fusion-composition timeline item has a real per-clip comp that
-        # accepts AddTool. No source media is required.
-        print("\n=== Setting up disposable project ===")
-        pm = handle.GetProjectManager()
-        project_name = "McpLiveSmoke_v25"
-        # Delete any leftover project from a prior failed run
-        try:
-            pm.DeleteProject(project_name)
-        except Exception:
-            pass
-        project = pm.CreateProject(project_name)
-        if project is None:
-            print("ABORT: CreateProject returned None")
-            sys.exit(1)
-        project_created = True
-        print(f"  Project: {project.GetName()}")
-
-        mp = project.GetMediaPool()
-        timeline = mp.CreateEmptyTimeline("McpSmokeTimeline")
-        if timeline is None:
-            print("ABORT: CreateEmptyTimeline returned None")
-            sys.exit(1)
-        print(f"  Timeline: {timeline.GetName()}")
-
-        # Insert a Fusion composition (gives us a timeline item with a
-        # real per-clip comp).
-        print("  Inserting Fusion composition into timeline...")
-        item = timeline.InsertFusionCompositionIntoTimeline()
-        if item is None:
-            print("  WARN: InsertFusionCompositionIntoTimeline returned None — "
-                  "will fall back to GetCurrentComp")
-
-        # Switch to Fusion page so the per-clip comp activates.
-        handle.OpenPage("fusion")
-        time.sleep(1)
-
-        fusion = handle.Fusion()
-        if fusion is None:
-            print("ABORT: handle.Fusion() returned None")
-            sys.exit(1)
-        comp = fusion.GetCurrentComp()
-        if comp is None:
-            print("ABORT: GetCurrentComp returned None")
-            sys.exit(1)
-
-        comp_attrs = comp.GetAttrs() or {}
-        print(f"  Comp: {comp_attrs.get('COMPS_Name', '?')}")
-
-        # Allow Fusion's tool registry a moment to finish indexing Fuses
-        time.sleep(2)
-
-        # Test 1: built-in baseline. If this fails, we have a context issue.
-        print("\n=== Built-in baseline ===")
-        bg = _add_tool(comp, "Background")
-        if bg is None:
-            print("  [FAIL] AddTool('Background') returned None — context issue")
-            print("         Aborting Fuse tests; comp does not accept tools.")
-            return
-        print(f"  [OK]   Background -> {bg.GetAttrs().get('TOOLS_RegID', '?')}")
-        bg.Delete()
-
-        # Test 2: each generated Fuse
-        print("\n=== Instantiating generated Fuses ===")
-        for kind, name, _ in installed:
-            if kind == "modifier":
-                results.append((kind, name, "SKIP",
-                                "Modifier — flow AddTool doesn't apply"))
-                continue
-            try:
-                t = _add_tool(comp, name)
-                if t is None:
-                    results.append((kind, name, "FAIL",
-                                    "AddTool returned None — class not registered"))
-                else:
-                    attrs = t.GetAttrs() or {}
-                    results.append((kind, name, "OK",
-                                    f"created {attrs.get('TOOLS_RegID', '?')}"))
-                    try:
-                        t.Delete()
-                    except Exception:
-                        pass
-            except Exception as e:
-                results.append((kind, name, "ERR", str(e)))
-
-        print()
-        for kind, name, status, msg in results:
-            print(f"  [{status:4s}] {kind:18s} {name:30s} {msg}")
-
-    finally:
-        # Cleanup installed Fuses
-        print("\n=== Cleanup ===")
-        for kind, name, path in installed:
-            try:
-                os.unlink(path)
-                print(f"  removed: {os.path.basename(path)}")
-            except OSError:
-                pass
-
-        # Cleanup disposable project
-        if project_created and pm is not None and not args.keep_open:
-            try:
-                pm.CloseProject(pm.GetCurrentProject())
-                pm.DeleteProject("McpLiveSmoke_v25")
-                print("  removed: disposable project")
-            except Exception:
-                pass
-
-        if not args.keep_open:
-            print("  Quitting Resolve...")
-            _quit_resolve()
-
-    failed = [r for r in results if r[2] in ("FAIL", "ERR")]
-    if failed:
-        print(f"\n=== {len(failed)} FAILURE(S) ===")
-        sys.exit(1)
-    elif results:
-        passed = sum(1 for r in results if r[2] == "OK")
-        skipped = sum(1 for r in results if r[2] == "SKIP")
-        print(f"\n=== PASS: {passed} OK, {skipped} SKIP ===")
-    else:
-        print("\n=== ABORTED before any Fuse was tested ===")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

package/mcps/davinci-resolve-mcp/tests/live_fusion_composition_validation.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-"""Live validation for the Fusion Composition kernel."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-import tempfile
-import types
-from pathlib import Path
-
-
-def _install_mcp_stubs() -> None:
-    class FastMCP:
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def tool(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-        def resource(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-    def stdio_server(*args, **kwargs):
-        raise RuntimeError("stdio_server is not used by the live Fusion Composition harness")
-
-    anyio = types.ModuleType("anyio")
-    anyio.run = lambda func: func()
-
-    mcp = types.ModuleType("mcp")
-    server = types.ModuleType("mcp.server")
-    fastmcp = types.ModuleType("mcp.server.fastmcp")
-    stdio = types.ModuleType("mcp.server.stdio")
-
-    fastmcp.FastMCP = FastMCP
-    stdio.stdio_server = stdio_server
-
-    sys.modules.setdefault("anyio", anyio)
-    sys.modules.setdefault("mcp", mcp)
-    sys.modules.setdefault("mcp.server", server)
-    sys.modules.setdefault("mcp.server.fastmcp", fastmcp)
-    sys.modules.setdefault("mcp.server.stdio", stdio)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Live Fusion Composition kernel validation harness")
-    parser.add_argument("--keep-open", action="store_true", help="Leave the disposable project open for inspection.")
-    parser.add_argument(
-        "--output-dir",
-        type=Path,
-        default=None,
-        help="Directory for Fusion Composition JSON/Markdown reports. Defaults to a temp directory.",
-    )
-    args = parser.parse_args()
-
-    _install_mcp_stubs()
-    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-    original_argv = sys.argv[:]
-    sys.argv = [sys.argv[0]]
-    try:
-        import src.server as server
-    finally:
-        sys.argv = original_argv
-
-    output_dir = args.output_dir or Path(tempfile.mkdtemp(prefix="fusion-composition-probe-report_"))
-    from src.utils.fusion_composition_live_probe import run_probe
-
-    report = run_probe(server, output_dir, keep_open=args.keep_open)
-    if report["counts"].get("error", 0):
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/mcps/davinci-resolve-mcp/tests/live_fusion_keyframe_validation.py

@@ -1,116 +0,0 @@
-"""Live Resolve validation for the add_keyframe BezierSpline fix (PR #56).
-
-Connects to a running DaVinci Resolve, finds the disposable "Fusion
-Composition" clip on the current timeline, adds a Transform tool, and applies
-the EXACT technique used by the fixed `fusion_comp(action="add_keyframe")`
-handler:
-
-    if not inp.GetConnectedOutput():
-        tool.AddModifier(input_name, "BezierSpline")
-    tool[input_name][time] = value
-
-Then it reads the interpolated value at several frames and the keyframe list.
-This validates the Fusion technique against the live app, independent of the
-long-running MCP server process (which may still be serving pre-fix code).
-
-Run AFTER setting up a timeline whose video track 1 holds a Fusion Composition
-clip. Pass --tool-name to target a specific Transform (default: a fresh one).
-Read-only against source media; touches only the disposable comp.
-"""
-
-import os
-import sys
-
-PROJECT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, PROJECT)
-
-from src.utils.platform import get_resolve_paths
-
-paths = get_resolve_paths()
-os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
-os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
-sys.path.insert(0, paths["modules_path"])
-
-import DaVinciResolveScript as dvr_script  # noqa: E402
-
-
-def main():
-    resolve = dvr_script.scriptapp("Resolve")
-    if resolve is None:
-        print("FATAL: cannot connect to Resolve")
-        return 1
-
-    pm = resolve.GetProjectManager()
-    project = pm.GetCurrentProject()
-    timeline = project.GetCurrentTimeline()
-    print(f"project={project.GetName()!r} timeline={timeline.GetName()!r}")
-
-    # Find the Fusion Composition clip on video track 1.
-    item = None
-    for clip in timeline.GetItemListInTrack("video", 1) or []:
-        if clip.GetFusionCompCount() > 0:
-            item = clip
-            break
-    if item is None:
-        print("FATAL: no timeline item with a Fusion comp on V1")
-        return 1
-
-    comp = item.GetFusionCompByIndex(1)
-    tool_name = "MCPKeyTestLive"
-
-    comp.Lock()
-    try:
-        tool = comp.FindTool(tool_name) or comp.AddTool("Transform", -1, -1)
-        try:
-            tool.SetAttrs({"TOOLS_Name": tool_name})
-        except Exception:
-            pass
-
-        inp = tool["Size"]
-        # The fix: attach a spline the first time, then key it.
-        already = False
-        try:
-            already = inp.GetConnectedOutput() is not None
-        except Exception:
-            already = False
-        if not already:
-            tool.AddModifier("Size", "BezierSpline")
-        tool["Size"][0] = 1.0
-        tool["Size"][75] = 1.4
-    finally:
-        comp.Unlock()
-
-    v0 = tool.GetInput("Size", 0)
-    v37 = tool.GetInput("Size", 37)
-    v75 = tool.GetInput("Size", 75)
-    kfs = tool["Size"].GetKeyFrames()
-
-    print(f"get_input(Size, 0)  = {v0}")
-    print(f"get_input(Size, 37) = {v37}")
-    print(f"get_input(Size, 75) = {v75}")
-    print(f"GetKeyFrames()      = {kfs}  (raw {{index: frame}})")
-
-    # Mirror the fixed get_keyframes handler: frame positions are the VALUES of
-    # GetKeyFrames(); read each keyframed value back via GetInput(frame).
-    serialized = [
-        {"time": kfs[idx], "value": tool.GetInput("Size", kfs[idx])}
-        for idx in sorted(kfs)
-    ]
-    print(f"get_keyframes()     = {serialized}")
-
-    ok = (
-        abs(v0 - 1.0) < 1e-6
-        and abs(v75 - 1.4) < 1e-6
-        and 1.0 < v37 < 1.4  # genuine interpolation between the keyframes
-        and bool(kfs)
-        and serialized == [
-            {"time": 0.0, "value": 1.0},
-            {"time": 75.0, "value": 1.4},
-        ]
-    )
-    print("RESULT:", "PASS" if ok else "FAIL")
-    return 0 if ok else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())