@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,230 +0,0 @@
-import os
-import tempfile
-import unittest
-from unittest.mock import patch
-
-from src.server import (
-    _gallery_capabilities,
-    _grade_boundary_report,
-    _grade_capabilities,
-    _grade_item_snapshot,
-    _grade_version_restore,
-    _probe_color_node_graph,
-    _safe_export_lut,
-    _safe_set_cdl,
-    _validate_cdl_payload,
-)
-
-
-class GraphStub:
-    def __init__(self, nodes=1):
-        self.nodes = nodes
-
-    def GetNumNodes(self):
-        return self.nodes
-
-    def GetLUT(self, node_index):
-        return "No LUT"
-
-    def GetNodeCacheMode(self, node_index):
-        return 0
-
-    def GetNodeLabel(self, node_index):
-        return f"Node {node_index}"
-
-    def GetToolsInNode(self, node_index):
-        return {}
-
-    def ApplyGradeFromDRX(self, path, grade_mode):
-        return True
-
-
-class ColorGroupStub:
-    def __init__(self, name="Look Group"):
-        self.name = name
-
-    def GetName(self):
-        return self.name
-
-    def GetPreClipNodeGraph(self):
-        return GraphStub()
-
-    def GetPostClipNodeGraph(self):
-        return GraphStub()
-
-
-class GalleryStub:
-    def __init__(self):
-        self.albums = [object()]
-        self.power = [object()]
-
-    def GetGalleryStillAlbums(self):
-        return self.albums
-
-    def GetGalleryPowerGradeAlbums(self):
-        return self.power
-
-    def GetAlbumName(self, album):
-        return "Album"
-
-    def GetCurrentStillAlbum(self):
-        return self.albums[0]
-
-    def SetCurrentStillAlbum(self, album):
-        return True
-
-    def CreateGalleryStillAlbum(self):
-        return object()
-
-    def CreateGalleryPowerGradeAlbum(self):
-        return object()
-
-
-class ProjectStub:
-    def __init__(self):
-        self.gallery = GalleryStub()
-        self.groups = [ColorGroupStub()]
-
-    def GetGallery(self):
-        return self.gallery
-
-    def GetColorGroupsList(self):
-        return self.groups
-
-    def AddColorGroup(self, name):
-        group = ColorGroupStub(name)
-        self.groups.append(group)
-        return group
-
-    def DeleteColorGroup(self, group):
-        return True
-
-
-class ItemStub:
-    def __init__(self):
-        self.cdl_calls = []
-        self.lut_exports = []
-
-    def GetName(self):
-        return "Color Clip"
-
-    def GetUniqueId(self):
-        return "item-1"
-
-    def GetNodeGraph(self, *args):
-        return GraphStub(nodes=2)
-
-    def GetCurrentVersion(self):
-        return {"versionName": "Default"}
-
-    def GetVersionNameList(self, version_type):
-        return ["Default", "Look"] if version_type == 0 else []
-
-    def LoadVersionByName(self, name, version_type):
-        return name == "Look"
-
-    def GetColorGroup(self):
-        return None
-
-    def GetIsColorOutputCacheEnabled(self):
-        return False
-
-    def GetIsFusionOutputCacheEnabled(self):
-        return False
-
-    def SetCDL(self, cdl):
-        self.cdl_calls.append(cdl)
-        return True
-
-    def ExportLUT(self, export_type, path):
-        self.lut_exports.append({"type": export_type, "path": path})
-        with open(path, "w", encoding="utf-8") as handle:
-            handle.write("LUT")
-        return True
-
-
-class ColorGradeProbeTest(unittest.TestCase):
-    def test_validate_cdl_payload_normalizes_numeric_triplets(self):
-        validation, err = _validate_cdl_payload(
-            {
-                "NodeIndex": "1",
-                "Slope": [1.1, 1.0, 0.9],
-                "Offset": "0.0 0.0 0.0",
-                "Power": [1, 1, 1],
-                "Saturation": "0.8",
-            }
-        )
-
-        self.assertIsNone(err)
-        self.assertTrue(validation["valid"])
-        self.assertEqual(validation["cdl"]["NodeIndex"], 1)
-        self.assertEqual(validation["cdl"]["Offset"], [0.0, 0.0, 0.0])
-
-    def test_safe_set_cdl_dry_run_does_not_mutate(self):
-        item = ItemStub()
-        result = _safe_set_cdl(
-            item,
-            {
-                "dry_run": True,
-                "cdl": {
-                    "NodeIndex": 1,
-                    "Slope": [1.0, 1.0, 1.0],
-                    "Offset": [0.0, 0.0, 0.0],
-                    "Power": [1.0, 1.0, 1.0],
-                    "Saturation": 1.0,
-                },
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(item.cdl_calls, [])
-
-    def test_grade_item_snapshot_includes_node_graph_and_versions(self):
-        snapshot = _grade_item_snapshot(ItemStub(), ProjectStub())
-
-        self.assertEqual(snapshot["name"], "Color Clip")
-        self.assertEqual(snapshot["node_graph"]["num_nodes"], 2)
-        self.assertIn("Look", snapshot["versions"]["local"])
-
-    def test_probe_color_node_graph_reads_group_source(self):
-        result = _probe_color_node_graph(
-            ProjectStub(),
-            ItemStub(),
-            {"source": "color_group_pre", "group_name": "Look Group"},
-        )
-
-        self.assertTrue(result["available"])
-        self.assertEqual(result["source"], "color_group_pre")
-
-    def test_safe_export_lut_requires_temp_path(self):
-        result = _safe_export_lut(ItemStub(), {"path": os.path.join(os.getcwd(), "look.cube")})
-
-        self.assertIn("error", result)
-        self.assertIn("system temp", (result["error"].get("message","") if isinstance(result["error"], dict) else result["error"]))
-
-    def test_safe_export_lut_writes_temp_file(self):
-        path = os.path.join(tempfile.mkdtemp(), "look.cube")
-        with patch("src.server.get_resolve", return_value=None):
-            result = _safe_export_lut(ItemStub(), {"path": path, "type": 33})
-
-        self.assertTrue(result["success"])
-        self.assertTrue(result["file_exists"])
-        self.assertGreater(result["size"], 0)
-
-    def test_grade_version_restore_dry_run_checks_name(self):
-        result = _grade_version_restore(ItemStub(), {"name": "Look", "dry_run": True})
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["would_load"], "Look")
-
-    def test_capability_reports_include_gallery_and_boundaries(self):
-        project = ProjectStub()
-        item = ItemStub()
-
-        self.assertTrue(_grade_capabilities(item, project)["gallery_available"])
-        self.assertTrue(_gallery_capabilities(project)["available"])
-        self.assertIn("color_groups", _grade_boundary_report(project, item, {"include_timeline_graph": False}))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,85 +0,0 @@
-"""Contract tests for B2 — confirm-token gate.
-
-See local/design/agentic-flow-improvements-gameplan.md §3 task B2.
-"""
-import unittest
-
-import src.server as compound
-
-
-class ConfirmTokenLifecycleTest(unittest.TestCase):
-    def setUp(self):
-        compound._CONFIRM_TOKENS.clear()
-
-    def test_fingerprint_stable_across_calls(self):
-        fp1 = compound._confirm_token_fingerprint("act", {"path": "/x", "k": 1})
-        fp2 = compound._confirm_token_fingerprint("act", {"path": "/x", "k": 1})
-        self.assertEqual(fp1, fp2)
-
-    def test_fingerprint_changes_with_params(self):
-        fp1 = compound._confirm_token_fingerprint("act", {"path": "/x"})
-        fp2 = compound._confirm_token_fingerprint("act", {"path": "/y"})
-        self.assertNotEqual(fp1, fp2)
-
-    def test_fingerprint_ignores_confirm_token_itself(self):
-        fp1 = compound._confirm_token_fingerprint("act", {"k": 1})
-        fp2 = compound._confirm_token_fingerprint("act", {"k": 1, "confirm_token": "abc"})
-        self.assertEqual(fp1, fp2)
-
-    def test_issue_returns_pending_user_decision_structured_error(self):
-        out = compound._issue_confirm_token(
-            action="x", params={"k": 1}, preview={"warning": "boom"},
-        )
-        self.assertIn("error", out)
-        self.assertEqual(out["error"]["category"], "pending_user_decision")
-        self.assertEqual(out["error"]["code"], "CONFIRMATION_REQUIRED")
-        self.assertIn("confirm_token", out)
-        self.assertEqual(out["status"], "confirmation_required")
-        self.assertEqual(out["preview"]["warning"], "boom")
-
-    def test_consume_with_no_token_returns_none(self):
-        """No token in params + gating on means 'caller should issue one' (not blocked)."""
-        result = compound._consume_confirm_token(action="x", params={"k": 1})
-        self.assertIsNone(result)
-
-    def test_consume_with_valid_token_proceeds(self):
-        issued = compound._issue_confirm_token(action="x", params={"k": 1}, preview={})
-        token = issued["confirm_token"]
-        result = compound._consume_confirm_token(action="x", params={"k": 1, "confirm_token": token})
-        self.assertIsNone(result)
-
-    def test_token_is_single_use(self):
-        issued = compound._issue_confirm_token(action="x", params={"k": 1}, preview={})
-        token = issued["confirm_token"]
-        ok1 = compound._consume_confirm_token(action="x", params={"k": 1, "confirm_token": token})
-        self.assertIsNone(ok1)
-        ok2 = compound._consume_confirm_token(action="x", params={"k": 1, "confirm_token": token})
-        self.assertIsNotNone(ok2)
-        self.assertEqual(ok2["error"]["code"], "CONFIRM_TOKEN_INVALID")
-
-    def test_wrong_action_rejected(self):
-        issued = compound._issue_confirm_token(action="x", params={"k": 1}, preview={})
-        token = issued["confirm_token"]
-        blocked = compound._consume_confirm_token(action="y", params={"k": 1, "confirm_token": token})
-        self.assertIsNotNone(blocked)
-        self.assertEqual(blocked["error"]["code"], "CONFIRM_TOKEN_ACTION_MISMATCH")
-
-    def test_changed_params_rejected(self):
-        issued = compound._issue_confirm_token(action="x", params={"k": 1}, preview={})
-        token = issued["confirm_token"]
-        blocked = compound._consume_confirm_token(action="x", params={"k": 2, "confirm_token": token})
-        self.assertIsNotNone(blocked)
-        self.assertEqual(blocked["error"]["code"], "CONFIRM_TOKEN_FINGERPRINT_MISMATCH")
-
-    def test_expired_token_rejected(self):
-        issued = compound._issue_confirm_token(action="x", params={"k": 1}, preview={})
-        token = issued["confirm_token"]
-        # Force expiry
-        compound._CONFIRM_TOKENS[token]["expires_at"] = 0
-        blocked = compound._consume_confirm_token(action="x", params={"k": 1, "confirm_token": token})
-        self.assertIsNotNone(blocked)
-        self.assertEqual(blocked["error"]["code"], "CONFIRM_TOKEN_INVALID")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,22 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-import src.server as compound
-
-
-class ConfirmTokenPreferenceTests(unittest.TestCase):
-    def test_confirm_token_gate_honors_destructive_preference_false(self):
-        with patch.object(
-            compound,
-            "_read_media_analysis_preferences",
-            return_value={"destructive": {"require_confirm_token": False}},
-        ):
-            self.assertFalse(compound._confirm_token_required())
-
-    def test_confirm_token_gate_defaults_to_required(self):
-        with patch.object(compound, "_read_media_analysis_preferences", return_value={}):
-            self.assertTrue(compound._confirm_token_required())
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,81 +0,0 @@
-"""Tests for the declarative parameter-contract validator and safe subprocess wrappers."""
-import subprocess
-import unittest
-
-from src.utils.contracts import validate
-from src.utils import proc
-
-
-class ValidateTest(unittest.TestCase):
-    def test_required_missing(self):
-        err, clean = validate({}, {"x": {"type": int, "required": True}})
-        self.assertIn("'x' is required", err)
-        self.assertIsNone(clean)
-
-    def test_default_applied(self):
-        err, clean = validate({}, {"k": {"enum": ["a", "b"], "default": "a"}})
-        self.assertIsNone(err)
-        self.assertEqual(clean["k"], "a")
-
-    def test_int_coercion(self):
-        err, clean = validate({"n": "42"}, {"n": {"type": int}})
-        self.assertIsNone(err)
-        self.assertEqual(clean["n"], 42)
-
-    def test_int_bad(self):
-        err, _ = validate({"n": "x"}, {"n": {"type": int}})
-        self.assertIn("must be an integer", err)
-
-    def test_enum_reject(self):
-        err, _ = validate({"k": "z"}, {"k": {"enum": ["a", "b"]}})
-        self.assertIn("must be one of: a, b", err)
-
-    def test_non_empty(self):
-        err, _ = validate({"s": "   "}, {"s": {"type": str, "non_empty": True}})
-        self.assertIn("must be non-empty", err)
-
-    def test_min_max(self):
-        self.assertIn("must be >= 0", validate({"n": -1}, {"n": {"type": int, "min": 0}})[0])
-        self.assertIn("must be <= 10", validate({"n": 11}, {"n": {"type": int, "max": 10}})[0])
-
-    def test_parent_dir_exists(self):
-        err, _ = validate({"p": "/no/such/dir/x.png"}, {"p": {"type": str, "parent_dir_exists": True}})
-        self.assertIn("target directory does not exist", err)
-        err2, clean = validate({"p": "/tmp/x.png"}, {"p": {"type": str, "parent_dir_exists": True}})
-        self.assertIsNone(err2)
-        self.assertEqual(clean["p"], "/tmp/x.png")
-
-    def test_invariant(self):
-        err, _ = validate(
-            {"a": 5, "b": 3},
-            {"a": {"type": int}, "b": {"type": int}},
-            invariants=[lambda c: "a must be <= b" if c["a"] > c["b"] else None],
-        )
-        self.assertEqual(err, "a must be <= b")
-
-    def test_invariant_passes(self):
-        err, clean = validate(
-            {"a": 1, "b": 3},
-            {"a": {"type": int}, "b": {"type": int}},
-            invariants=[lambda c: "a must be <= b" if c["a"] > c["b"] else None],
-        )
-        self.assertIsNone(err)
-        self.assertEqual(clean["a"], 1)
-
-
-class SafeRunTest(unittest.TestCase):
-    def test_safe_run_defaults_stdin_devnull(self):
-        # echo via python; the point is stdin is DEVNULL and it doesn't hang/inherit.
-        r = proc.safe_run(["python3", "-c", "print('ok')"], capture_output=True, text=True, timeout=10)
-        self.assertEqual(r.returncode, 0)
-        self.assertIn("ok", r.stdout)
-
-    def test_safe_run_allows_input(self):
-        # input= and stdin are mutually exclusive in subprocess; safe_run must
-        # not inject DEVNULL when input is provided.
-        r = proc.safe_run(["cat"], input="hello", capture_output=True, text=True, timeout=10)
-        self.assertEqual(r.stdout, "hello")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,111 +0,0 @@
-"""Tests for CreateSubtitlesFromAudio settings normalization + readback.
-
-Sibling of the issue #70 AutoSyncAudio fix: autoCaptionSettings is keyed by
-resolve.SUBTITLE_* enum constants with resolve.AUTO_CAPTION_* enum values, so
-human-readable strings must be resolved against the live handle and unknown keys
-dropped (not forwarded, which silently fails the whole call).
-"""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class FakeResolve:
-    SUBTITLE_LANGUAGE = "__LANG__"
-    SUBTITLE_CAPTION_PRESET = "__PRESET__"
-    SUBTITLE_LINE_BREAK = "__LINEBREAK__"
-    SUBTITLE_CHARS_PER_LINE = "__CPL__"
-    SUBTITLE_GAP = "__GAP__"
-    AUTO_CAPTION_KOREAN = "__KOREAN__"
-    AUTO_CAPTION_ENGLISH = "__ENGLISH__"
-    AUTO_CAPTION_NETFLIX = "__NETFLIX__"
-    AUTO_CAPTION_SUBTITLE_DEFAULT = "__DEFAULT__"
-    AUTO_CAPTION_LINE_SINGLE = "__SINGLE__"
-    AUTO_CAPTION_LINE_DOUBLE = "__DOUBLE__"
-
-
-class NormalizeTest(unittest.TestCase):
-    def test_language_resolves_to_enum(self):
-        out, ignored = s._normalize_auto_caption_settings({"language": "korean"}, FakeResolve())
-        self.assertEqual(out["__LANG__"], "__KOREAN__")
-        self.assertEqual(ignored, [])
-
-    def test_preset_and_line_break_resolve(self):
-        out, _ = s._normalize_auto_caption_settings(
-            {"preset": "netflix", "line_break": "double"}, FakeResolve()
-        )
-        self.assertEqual(out["__PRESET__"], "__NETFLIX__")
-        self.assertEqual(out["__LINEBREAK__"], "__DOUBLE__")
-
-    def test_chars_per_line_clamped(self):
-        hi, _ = s._normalize_auto_caption_settings({"chars_per_line": 999}, FakeResolve())
-        lo, _ = s._normalize_auto_caption_settings({"chars_per_line": 0}, FakeResolve())
-        self.assertEqual(hi["__CPL__"], 60)
-        self.assertEqual(lo["__CPL__"], 1)
-
-    def test_gap_clamped(self):
-        out, _ = s._normalize_auto_caption_settings({"gap": 50}, FakeResolve())
-        self.assertEqual(out["__GAP__"], 10)
-
-    def test_unknown_language_value_is_reported_not_forwarded(self):
-        out, ignored = s._normalize_auto_caption_settings({"language": "klingon"}, FakeResolve())
-        self.assertEqual(out, {})
-        self.assertEqual(ignored, ["language"])
-
-    def test_unknown_key_is_dropped(self):
-        out, ignored = s._normalize_auto_caption_settings(
-            {"language": "english", "group_id": "x"}, FakeResolve()
-        )
-        self.assertEqual(out, {"__LANG__": "__ENGLISH__"})
-        self.assertEqual(ignored, ["group_id"])
-
-    def test_no_raw_strings_leak(self):
-        out, _ = s._normalize_auto_caption_settings({"language": "korean"}, FakeResolve())
-        self.assertNotIn("korean", out.values())
-        self.assertNotIn("language", out)
-
-
-class SafeCreateSubtitlesTest(unittest.TestCase):
-    def test_dry_run_returns_resolved_settings_and_ignored(self):
-        tl = mock.Mock()
-        with mock.patch.object(s, "get_resolve", return_value=FakeResolve()):
-            out = s._safe_create_subtitles(
-                tl, {"settings": {"language": "korean", "bogus": 1}, "dry_run": True}
-            )
-        self.assertTrue(out["would_create_subtitles"])
-        self.assertEqual(out["settings"]["__LANG__"], "__KOREAN__")
-        self.assertEqual(out["ignored_settings"], ["bogus"])
-        tl.CreateSubtitlesFromAudio.assert_not_called()
-
-    def test_readback_verifies_track_added(self):
-        tl = mock.Mock()
-        counts = iter([0, 1])  # before=0, after=1
-
-        tl.GetTrackCount.side_effect = lambda kind: {"subtitle": next(counts)}[kind]
-        tl.CreateSubtitlesFromAudio.return_value = True
-        with mock.patch.object(s, "get_resolve", return_value=FakeResolve()):
-            out = s._safe_create_subtitles(
-                tl, {"settings": {"language": "english"}, "dry_run": False}
-            )
-        # Resolved enum reached the API.
-        called_with = tl.CreateSubtitlesFromAudio.call_args[0][0]
-        self.assertEqual(called_with["__LANG__"], "__ENGLISH__")
-        self.assertTrue(out["success"])
-        self.assertTrue(out["verified"])
-        self.assertEqual(out["subtitle_tracks_before"], 0)
-        self.assertEqual(out["subtitle_tracks_after"], 1)
-
-    def test_readback_catches_lying_boolean(self):
-        # API says True but no subtitle track appears -> verified False.
-        tl = mock.Mock()
-        tl.GetTrackCount.return_value = 2  # unchanged before/after
-        tl.CreateSubtitlesFromAudio.return_value = True
-        with mock.patch.object(s, "get_resolve", return_value=FakeResolve()):
-            out = s._safe_create_subtitles(tl, {"settings": {}, "dry_run": False})
-        self.assertTrue(out["success"])
-        self.assertFalse(out["verified"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,137 +0,0 @@
-#!/usr/bin/env python3
-"""
-DaVinci Resolve MCP Server Test Script for Custom Timeline Creation
-------------------------------------------------------------------
-This script tests the enhanced CreateEmptyTimeline function with custom parameters.
-
-Usage:
-    python test_custom_timeline.py
-
-Requirements:
-    - DaVinci Resolve must be running with a project open
-    - DaVinci Resolve MCP Server must be running (after restart)
-    - requests module (pip install requests)
-"""
-
-import sys
-import time
-import requests
-import logging
-from typing import Dict, Any
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("custom_timeline_test.log"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Server configuration
-SERVER_URL = "http://localhost:8000/api"
-
-def send_request(tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
-    """Send a request to the MCP server."""
-    try:
-        payload = {
-            "tool": tool_name,
-            "params": params
-        }
-        logger.info(f"Sending request: {tool_name} with params {params}")
-        response = requests.post(SERVER_URL, json=payload)
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request error: {e}")
-        return {"success": False, "error": str(e)}
-
-def test_basic_timeline_creation():
-    """Test basic timeline creation."""
-    logger.info("Testing basic timeline creation...")
-    
-    # Create a test timeline with default settings
-    timeline_name = f"Basic_Test_Timeline_{int(time.time())}"
-    result = send_request("mcp_davinci_resolve_create_timeline", {"name": timeline_name})
-    
-    if "error" in result and result.get("error"):
-        logger.error(f"❌ Basic timeline creation failed: {result.get('error')}")
-        return False
-    else:
-        logger.info(f"✅ Basic timeline created: {timeline_name}")
-        return True
-
-def test_custom_timeline_creation():
-    """Test enhanced timeline creation with custom parameters."""
-    logger.info("Testing custom timeline creation...")
-    
-    # Create a custom timeline with specific parameters
-    timeline_name = f"Custom_Test_Timeline_{int(time.time())}"
-    params = {
-        "name": timeline_name,
-        "frame_rate": "23.976",
-        "resolution_width": 3840,
-        "resolution_height": 2160,
-        "start_timecode": "01:00:00:00"
-    }
-    
-    result = send_request("mcp_davinci_resolve_create_empty_timeline", params)
-    
-    if "error" in result and result.get("error"):
-        logger.error(f"❌ Custom timeline creation failed: {result.get('error')}")
-        return False
-    else:
-        logger.info(f"✅ Custom timeline created with parameters: {params}")
-        
-        # Verify the timeline settings
-        logger.info("Retrieving timeline info to verify settings...")
-        
-        # Switch to the created timeline
-        switch_result = send_request("mcp_davinci_resolve_set_current_timeline", {"name": timeline_name})
-        if "error" in switch_result and switch_result.get("error"):
-            logger.error(f"❌ Failed to switch to timeline: {switch_result.get('error')}")
-            return False
-        
-        # Get timeline info
-        get_timeline_result = send_request("mcp_davinci_resolve_get_current_timeline", {})
-        if "error" in get_timeline_result or not isinstance(get_timeline_result, dict):
-            logger.error(f"❌ Failed to get timeline info: {get_timeline_result}")
-            return False
-        
-        # Verify settings
-        resolution = get_timeline_result.get("resolution", {})
-        
-        logger.info(f"Timeline info: {get_timeline_result}")
-        logger.info(f"Resolution: {resolution}")
-        logger.info(f"Framerate: {get_timeline_result.get('framerate')}")
-        logger.info(f"Start timecode: {get_timeline_result.get('start_timecode')}")
-        
-        return True
-
-def main():
-    """Run the timeline creation tests."""
-    logger.info("Starting DaVinci Resolve MCP custom timeline creation tests")
-    logger.info("=" * 60)
-    
-    # Run tests
-    basic_result = test_basic_timeline_creation()
-    custom_result = test_custom_timeline_creation()
-    
-    # Summary
-    logger.info("=" * 60)
-    logger.info(f"Basic timeline creation: {'✅ PASSED' if basic_result else '❌ FAILED'}")
-    logger.info(f"Custom timeline creation: {'✅ PASSED' if custom_result else '❌ FAILED'}")
-    logger.info("=" * 60)
-    
-    # Exit with appropriate code
-    if basic_result and custom_result:
-        logger.info("All tests passed!")
-        sys.exit(0)
-    else:
-        logger.error("Some tests failed. Check the logs for details.")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()