@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,179 +0,0 @@
-"""Contract tests for the A1 structured error envelope and D1 retryable defaults.
-
-See local/design/agentic-flow-improvements-gameplan.md §3 task A1
-and local/design/agentic-flow-improvements-gameplan-2.md §3 task D1.
-"""
-import unittest
-
-from src.server import _err, ERROR_CATEGORIES, _CATEGORY_RETRYABLE_DEFAULT
-
-
-class ErrorEnvelopeContractTest(unittest.TestCase):
-    def test_default_shape_is_structured(self):
-        out = _err("something went wrong")
-        self.assertIn("error", out)
-        body = out["error"]
-        self.assertIsInstance(body, dict)
-        self.assertEqual(body["message"], "something went wrong")
-        self.assertEqual(body["code"], "UNSPECIFIED")
-        self.assertEqual(body["category"], "resolve_api_failed")
-        # D1: resolve_api_failed defaults to retryable=True when retryable is omitted.
-        self.assertTrue(body["retryable"])
-        self.assertNotIn("remediation", body)
-        self.assertNotIn("reason", body)
-
-    def test_named_code_category_retryable_remediation(self):
-        out = _err(
-            "no project",
-            code="NO_PROJECT",
-            category="precondition",
-            retryable=False,
-            remediation="open one",
-        )
-        body = out["error"]
-        self.assertEqual(body["code"], "NO_PROJECT")
-        self.assertEqual(body["category"], "precondition")
-        self.assertFalse(body["retryable"])
-        self.assertEqual(body["remediation"], "open one")
-
-    def test_unknown_category_falls_back_to_resolve_api_failed(self):
-        out = _err("boom", category="invented_category")
-        self.assertEqual(out["error"]["category"], "resolve_api_failed")
-
-    def test_message_is_always_stringified(self):
-        out = _err(123)
-        self.assertEqual(out["error"]["message"], "123")
-
-    def test_category_enum_locked(self):
-        expected = {
-            "precondition",
-            "not_connected",
-            "wrong_page",
-            "invalid_input",
-            "resolve_api_failed",
-            "busy",
-            "destructive_blocked",
-            "pending_user_decision",
-            "unsupported",
-            "budget_exhausted",
-            "timeout",
-            "batch_partial",
-        }
-        self.assertEqual(set(ERROR_CATEGORIES), expected)
-
-    def test_every_category_has_retryable_default(self):
-        """D1: the lookup map must cover every category in ERROR_CATEGORIES."""
-        for cat in ERROR_CATEGORIES:
-            self.assertIn(cat, _CATEGORY_RETRYABLE_DEFAULT,
-                          f"category {cat!r} missing from _CATEGORY_RETRYABLE_DEFAULT")
-
-    def test_retryable_default_per_category(self):
-        """D1: lock the per-category default values; downstream agents route on these."""
-        cases = {
-            "precondition": False,
-            "not_connected": True,
-            "wrong_page": True,
-            "invalid_input": False,
-            "resolve_api_failed": True,
-            "busy": True,
-            "destructive_blocked": False,
-            "pending_user_decision": False,
-            "unsupported": False,
-            "budget_exhausted": False,
-            "timeout": True,
-            "batch_partial": False,
-        }
-        for cat, expected_retryable in cases.items():
-            with self.subTest(category=cat):
-                out = _err("x", category=cat)
-                self.assertEqual(out["error"]["retryable"], expected_retryable,
-                                 f"category {cat!r} expected retryable={expected_retryable}")
-
-    def test_explicit_retryable_override_wins(self):
-        """D1: an explicit retryable= keyword overrides the per-category default."""
-        # resolve_api_failed defaults True; force False.
-        out = _err("x", category="resolve_api_failed", retryable=False)
-        self.assertFalse(out["error"]["retryable"])
-        # precondition defaults False; force True.
-        out = _err("x", category="precondition", retryable=True)
-        self.assertTrue(out["error"]["retryable"])
-
-    def test_reason_field_carried_when_provided(self):
-        """D1: optional reason= keyword surfaces in the envelope (matches CAPS_REFUSAL shape)."""
-        out = _err("budget gone", category="budget_exhausted",
-                   reason="over_day_cap", remediation="raise the cap")
-        body = out["error"]
-        self.assertEqual(body["reason"], "over_day_cap")
-        self.assertFalse(body["retryable"])  # budget_exhausted default
-        self.assertEqual(body["remediation"], "raise the cap")
-
-    def test_no_caller_returns_bare_string_error(self):
-        """Sanity smoke: the helper itself always wraps in a dict."""
-        out = _err("x")
-        self.assertNotIsInstance(out["error"], str)
-
-    def test_state_field_carried_when_provided(self):
-        """state= surfaces a machine-readable snapshot at failure time."""
-        out = _err("no render job", category="resolve_api_failed",
-                   state={"queue_size": 0, "format": "mov"})
-        self.assertEqual(out["error"]["state"], {"queue_size": 0, "format": "mov"})
-
-    def test_state_omitted_when_empty(self):
-        """Empty/None state must not bloat the envelope."""
-        self.assertNotIn("state", _err("x")["error"])
-        self.assertNotIn("state", _err("x", state={})["error"])
-
-    def test_check_emits_structured_not_connected_when_resolve_absent(self):
-        """Integration smoke: _check returns a NOT_CONNECTED error when Resolve is unreachable."""
-        import src.server as compound
-
-        original = compound.get_resolve
-        compound.get_resolve = lambda: None
-        try:
-            _, _, err = compound._check()
-        finally:
-            compound.get_resolve = original
-
-        self.assertIsNotNone(err)
-        body = err["error"]
-        self.assertEqual(body["code"], "NOT_CONNECTED")
-        self.assertEqual(body["category"], "not_connected")
-        self.assertTrue(body["retryable"])
-        self.assertIn("Resolve", body["message"])
-        self.assertIn("remediation", body)
-
-    def test_validate_cdl_payload_returns_invalid_input(self):
-        """F1 — caller-side input validation on safe_set_cdl uses invalid_input,
-        not the default resolve_api_failed."""
-        import src.server as compound
-
-        _, err = compound._validate_cdl_payload("not a dict")
-        self.assertIsNotNone(err)
-        body = err["error"]
-        self.assertEqual(body["code"], "INVALID_CDL")
-        self.assertEqual(body["category"], "invalid_input")
-        self.assertIn("remediation", body)
-
-    def test_get_tl_emits_no_current_timeline(self):
-        """Integration smoke: _get_tl emits a precondition error with NO_CURRENT_TIMELINE code."""
-        import src.server as compound
-
-        class _StubProject:
-            def GetCurrentTimeline(self):
-                return None
-
-        original_check = compound._check
-        compound._check = lambda: (object(), _StubProject(), None)
-        try:
-            _, _, err = compound._get_tl()
-        finally:
-            compound._check = original_check
-
-        self.assertIsNotNone(err)
-        body = err["error"]
-        self.assertEqual(body["code"], "NO_CURRENT_TIMELINE")
-        self.assertEqual(body["category"], "precondition")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,101 +0,0 @@
-"""Tests for the exhaustive-audit Wave A hardening (gameplan Phase 6).
-
-Covers EX1 (spec hook no-shell), EX4 (confirm-token locking still issues/consumes),
-EX5 (negative-index rejection), EX8 (_safe_int clamps + numeric guards).
-"""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class SpecHookNoShellTest(unittest.TestCase):
-    """EX1: hooks run via argv (no shell), so injection metacharacters can't run."""
-
-    def _hook(self, command):
-        return mock.Mock(command=command, name="h")
-
-    def test_command_is_split_and_run_without_shell(self):
-        runner = s._make_spec_hook_runner()
-        with mock.patch("subprocess.run") as run:
-            run.return_value = mock.Mock(returncode=0)
-            ok = runner(self._hook('echo hello'))
-        self.assertTrue(ok)
-        args, kwargs = run.call_args
-        self.assertEqual(args[0], ["echo", "hello"])      # argv, not a string
-        self.assertFalse(kwargs.get("shell", False))      # never shell=True
-
-    def test_injection_string_is_argv_not_shell(self):
-        runner = s._make_spec_hook_runner()
-        with mock.patch("subprocess.run") as run:
-            run.return_value = mock.Mock(returncode=0)
-            runner(self._hook('rm -rf /; echo pwned'))
-        # The injection is parsed as argv tokens for `rm`, never as a shell
-        # command separator: shell=False and `echo`/`pwned` remain plain args.
-        argv = run.call_args[0][0]
-        self.assertEqual(argv[0], "rm")
-        self.assertIn("echo", argv)
-        self.assertIn("pwned", argv)
-        self.assertFalse(run.call_args[1].get("shell", False))
-
-    def test_empty_command_returns_false_without_running(self):
-        runner = s._make_spec_hook_runner()
-        with mock.patch("subprocess.run") as run:
-            self.assertFalse(runner(self._hook("   ")))
-            run.assert_not_called()
-
-
-class ConfirmTokenLockTest(unittest.TestCase):
-    """EX4: locking must not break the normal issue -> consume flow."""
-
-    def test_issue_then_consume_round_trip(self):
-        with mock.patch.object(s, "_confirm_token_required", return_value=True):
-            issued = s._issue_confirm_token(action="timeline.delete_track", params={"x": 1}, preview={})
-            token = issued["confirm_token"]
-            # Correct token + same params -> consume returns None (proceed).
-            blocked = s._consume_confirm_token(action="timeline.delete_track", params={"x": 1, "confirm_token": token})
-            self.assertIsNone(blocked)
-            # One-time use: second consume now fails.
-            again = s._consume_confirm_token(action="timeline.delete_track", params={"x": 1, "confirm_token": token})
-            self.assertIsInstance(again, dict)
-            self.assertIn("error", again)
-
-    def test_lock_exists(self):
-        self.assertTrue(hasattr(s, "_CONFIRM_TOKENS_LOCK"))
-
-
-class SafeIntTest(unittest.TestCase):
-    def test_non_numeric_returns_default(self):
-        self.assertEqual(s._safe_int("abc", 50), 50)
-        self.assertEqual(s._safe_int(None, 7), 7)
-
-    def test_clamps_to_bounds(self):
-        self.assertEqual(s._safe_int(-5, 50, minimum=1, maximum=1000), 1)
-        self.assertEqual(s._safe_int(99999, 50, minimum=1, maximum=1000), 1000)
-        self.assertEqual(s._safe_int("250", 50, minimum=1, maximum=1000), 250)
-
-
-class HistoryLimitClampTest(unittest.TestCase):
-    """EX8: negative limit must not become a SQLite full-table fetch."""
-
-    def test_brain_edits_clamps_negative_limit(self):
-        import src.utils.brain_edits as be
-        captured = {}
-
-        class FakeCursor:
-            def fetchall(self):
-                return []
-
-        class FakeConn:
-            def execute(self, sql, params):
-                captured["params"] = params
-                return FakeCursor()
-
-        with mock.patch.object(be.timeline_brain_db, "connect", return_value=FakeConn()):
-            be.get_brain_edit_history(project_root="/tmp/x", limit=-1)
-        # The LIMIT bind param is the last positional; must be clamped to >= 1.
-        self.assertGreaterEqual(captured["params"][-1], 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,77 +0,0 @@
-import unittest
-
-from src.server import (
-    _extension_capabilities,
-    _extension_template_matrix,
-    _probe_dctl_lifecycle,
-    _probe_fuse_lifecycle,
-    _probe_script_lifecycle,
-    _refresh_or_restart_required,
-    _safe_install_extension,
-)
-
-
-class ExtensionAuthoringProbeTest(unittest.TestCase):
-    def test_refresh_restart_classification(self):
-        fuse = _refresh_or_restart_required({"extension_type": "fuse"})
-        dctl_lut = _refresh_or_restart_required({"extension_type": "dctl", "category": "lut"})
-        dctl_aces = _refresh_or_restart_required({"extension_type": "dctl", "category": "aces_idt"})
-        script = _refresh_or_restart_required({"extension_type": "script", "category": "Utility"})
-
-        self.assertTrue(fuse["restart_required"])
-        self.assertTrue(dctl_lut["refresh_luts"])
-        self.assertTrue(dctl_aces["restart_required"])
-        self.assertFalse(script["restart_required"])
-
-    def test_capabilities_include_markers_and_templates(self):
-        caps = _extension_capabilities()
-
-        self.assertEqual(caps["markers"]["fuse"], "@mcp-fuse")
-        self.assertIn("color_matrix", caps["templates"]["fuse"])
-        self.assertIn("transform", caps["templates"]["dctl"])
-        self.assertIn("scaffold", caps["templates"]["script"])
-
-    def test_safe_install_dry_run_requires_mcp_name(self):
-        result = _safe_install_extension({
-            "extension_type": "fuse",
-            "name": "ClientFuse",
-            "kind": "color_matrix",
-            "dry_run": True,
-        })
-
-        self.assertIn("error", result)
-
-    def test_safe_install_dry_run_generates_marked_fuse(self):
-        result = _safe_install_extension({
-            "extension_type": "fuse",
-            "name": "_mcp_fuse_dry_run",
-            "kind": "color_matrix",
-            "dry_run": True,
-        })
-
-        self.assertTrue(result["success"])
-        self.assertTrue(result["would_install"])
-
-    def test_lifecycle_probes_are_dry_by_default(self):
-        fuse = _probe_fuse_lifecycle({"name": "_mcp_fuse_probe"})
-        dctl = _probe_dctl_lifecycle({"name": "_mcp_dctl_probe"})
-        script = _probe_script_lifecycle({"name": "_mcp_script_probe", "language": "py"})
-
-        self.assertTrue(fuse["has_marker"])
-        self.assertTrue(dctl["has_marker"])
-        self.assertTrue(script["has_marker"])
-        self.assertNotIn("install", fuse)
-        self.assertNotIn("install", dctl)
-        self.assertNotIn("install", script)
-
-    def test_template_matrix_covers_all_extension_types(self):
-        matrix = _extension_template_matrix()
-
-        self.assertGreaterEqual(len(matrix["fuse"]), 1)
-        self.assertGreaterEqual(len(matrix["dctl"]), 1)
-        self.assertGreaterEqual(len(matrix["script"]), 1)
-        self.assertTrue(all("validation" in row or "error" in row for row in matrix["fuse"].values()))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,42 +0,0 @@
-"""Tests for media_pool_item extract_frames (guards; happy path is live-validated)."""
-import os
-import tempfile
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class FakeClip:
-    def __init__(self, path):
-        self._p = path
-
-    def GetClipProperty(self, key):
-        return self._p if key == "File Path" else ""
-
-
-def _call(clip, params):
-    mp = mock.Mock()
-    with mock.patch.object(s, "_get_mp", return_value=(None, None, mp, None)), \
-         mock.patch.object(s, "_find_clip", return_value=clip):
-        return s.media_pool_item("extract_frames", params)
-
-
-class ExtractFramesGuardTest(unittest.TestCase):
-    def test_no_source_file(self):
-        out = _call(FakeClip("/no/such/file.mov"), {"clip_id": "x", "timestamps": [1.0]})
-        self.assertIn("error", out)
-
-    def test_no_timestamps(self):
-        fd, real = tempfile.mkstemp(suffix=".mov")
-        os.close(fd)
-        try:
-            out = _call(FakeClip(real), {"clip_id": "x"})
-            self.assertIn("error", out)
-            self.assertIn("timestamps", str(out).lower())
-        finally:
-            os.remove(real)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,129 +0,0 @@
-import unittest
-
-import src.server as compound
-
-
-class MediaPoolItemStub:
-    def __init__(self, file_path):
-        self.file_path = file_path
-
-    def GetClipProperty(self, key):
-        if key == "File Path":
-            return self.file_path
-        return None
-
-
-class TimelineItemStub:
-    def __init__(
-        self,
-        *,
-        name="Timeline Item",
-        file_path="/tmp/synthetic_source.mov",
-        start=86400,
-        end=86448,
-        left_offset=0,
-        unique_id="timeline-item-1",
-    ):
-        self.name = name
-        self.media_pool_item = MediaPoolItemStub(file_path)
-        self.start = start
-        self.end = end
-        self.left_offset = left_offset
-        self.unique_id = unique_id
-
-    def GetName(self):
-        return self.name
-
-    def GetMediaPoolItem(self):
-        return self.media_pool_item
-
-    def GetStart(self):
-        return self.start
-
-    def GetEnd(self):
-        return self.end
-
-    def GetLeftOffset(self):
-        return self.left_offset
-
-    def GetUniqueId(self):
-        return self.unique_id
-
-
-class TimelineStub:
-    def __init__(self, items):
-        self.items = items
-
-    def GetName(self):
-        return "source_ranges_timeline"
-
-    def GetTrackCount(self, track_type):
-        return 1 if track_type == "video" else 0
-
-    def GetItemListInTrack(self, track_type, track_index):
-        if track_type == "video" and track_index == 1:
-            return self.items
-        return []
-
-
-class ProjectStub:
-    def __init__(self, timeline):
-        self.timeline = timeline
-
-    def GetCurrentTimeline(self):
-        return self.timeline
-
-
-class ExtractSourceFrameRangesTest(unittest.TestCase):
-    def setUp(self):
-        self.original_check = compound._check
-
-    def tearDown(self):
-        compound._check = self.original_check
-
-    def _install_timeline(self, items):
-        timeline = TimelineStub(items)
-        project = ProjectStub(timeline)
-        compound._check = lambda: (None, project, None)
-        return timeline
-
-    def test_handles_zero_keeps_inclusive_end_on_last_used_frame(self):
-        self._install_timeline(
-            [
-                TimelineItemStub(
-                    file_path="/media/synthetic_48_frame_clip.mov",
-                    start=86400,
-                    end=86448,
-                    left_offset=0,
-                )
-            ]
-        )
-
-        out = compound.timeline("extract_source_frame_ranges", {"handles": 0})
-
-        self.assertEqual(out["clip_count"], 1)
-        self.assertEqual(out["occurrences"][0]["source_used_inclusive_end"], 47)
-        self.assertEqual(out["occurrences"][0]["source_range_final"], [0, 47])
-        self.assertEqual(out["frame_ranges"], {"synthetic_48_frame_clip.mov": [[0, 47]]})
-
-    def test_fixed_handles_extend_from_inclusive_used_range(self):
-        self._install_timeline(
-            [
-                TimelineItemStub(
-                    file_path="/media/synthetic_48_frame_clip.mov",
-                    start=86400,
-                    end=86448,
-                    left_offset=12,
-                )
-            ]
-        )
-
-        out = compound.timeline("extract_source_frame_ranges", {"handles": 8})
-
-        self.assertEqual(out["occurrences"][0]["source_used_inclusive_end"], 59)
-        self.assertEqual(out["occurrences"][0]["source_range_final"], [4, 67])
-        self.assertEqual(out["frame_ranges"], {"synthetic_48_frame_clip.mov": [[4, 67]]})
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,103 +0,0 @@
-"""E2 contract test — repeated-failure escalation tracker.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task E2.
-"""
-import unittest
-
-from src.utils import failure_tracker as ft
-
-
-class FailureTrackerTest(unittest.TestCase):
-    def setUp(self):
-        ft.reset_all()
-
-    def tearDown(self):
-        ft.reset_all()
-
-    def test_three_failures_in_window_returns_escalation(self):
-        # Same scope, same action, 3 failures within window.
-        t0 = 1000.0
-        for offset in (0, 10, 20):
-            ft.record_failure("clip-a", "analyze_clip", now=t0 + offset)
-        out = ft.build_escalation_block("clip-a", "analyze_clip",
-                                         error_category="resolve_api_failed",
-                                         now=t0 + 21)
-        self.assertIsNotNone(out)
-        self.assertTrue(out["recommended"])
-        self.assertEqual(out["reason"], "repeated_failure")
-        self.assertEqual(out["failure_count"], 3)
-        self.assertIn("analyze_clip", out["suggested_action"])
-        self.assertIn("clip-a", out["suggested_action"])
-
-    def test_two_failures_then_success_clears_counter(self):
-        t0 = 1000.0
-        ft.record_failure("clip-a", "analyze_clip", now=t0)
-        ft.record_failure("clip-a", "analyze_clip", now=t0 + 5)
-        ft.record_success("clip-a", "analyze_clip")
-        ft.record_failure("clip-a", "analyze_clip", now=t0 + 10)
-        # Only the post-success failure should count → no escalation.
-        out = ft.build_escalation_block("clip-a", "analyze_clip",
-                                         error_category="resolve_api_failed",
-                                         now=t0 + 11)
-        self.assertIsNone(out)
-
-    def test_failures_spread_beyond_window_do_not_escalate(self):
-        # 3 failures spaced > window → only the most recent stays in.
-        for offset in (0, 1000, 2000):
-            ft.record_failure("clip-a", "analyze_clip", now=offset, window_seconds=600)
-        out = ft.build_escalation_block("clip-a", "analyze_clip",
-                                         error_category="resolve_api_failed",
-                                         now=2100, window_seconds=600)
-        self.assertIsNone(out)
-
-    def test_different_scope_keys_are_independent(self):
-        t0 = 1000.0
-        for offset in (0, 10, 20):
-            ft.record_failure("clip-a", "analyze_clip", now=t0 + offset)
-        # 3 failures on clip-a, 0 failures on clip-b.
-        self.assertIsNotNone(ft.build_escalation_block("clip-a", "analyze_clip",
-                                                        error_category="x", now=t0 + 21))
-        self.assertIsNone(ft.build_escalation_block("clip-b", "analyze_clip",
-                                                     error_category="x", now=t0 + 21))
-
-    def test_different_actions_on_same_scope_are_independent(self):
-        t0 = 1000.0
-        for offset in (0, 10, 20):
-            ft.record_failure("clip-a", "analyze_clip", now=t0 + offset)
-        # analyze_clip escalates; commit_vision (no failures) does not.
-        self.assertIsNotNone(ft.build_escalation_block("clip-a", "analyze_clip",
-                                                        error_category="x", now=t0 + 21))
-        self.assertIsNone(ft.build_escalation_block("clip-a", "commit_vision",
-                                                     error_category="x", now=t0 + 21))
-
-    def test_no_scope_sentinel_groups_failures_correctly(self):
-        """Calls with no scope_key (None) collapse into a shared bucket."""
-        t0 = 1000.0
-        for offset in (0, 10, 20):
-            ft.record_failure(None, "open_control_panel", now=t0 + offset)
-        out = ft.build_escalation_block(None, "open_control_panel",
-                                         error_category="resolve_api_failed",
-                                         now=t0 + 21)
-        self.assertIsNotNone(out)
-        self.assertEqual(out["failure_count"], 3)
-
-    def test_get_failure_state_does_not_record(self):
-        """Pure read; shouldn't increment counters or trigger escalation."""
-        state1 = ft.get_failure_state("clip-a", "analyze_clip")
-        state2 = ft.get_failure_state("clip-a", "analyze_clip")
-        self.assertEqual(state1["failure_count"], 0)
-        self.assertEqual(state2["failure_count"], 0)
-
-    def test_threshold_is_configurable(self):
-        t0 = 1000.0
-        ft.record_failure("clip-a", "x", now=t0)
-        ft.record_failure("clip-a", "x", now=t0 + 1)
-        # threshold=2 → escalate at 2 failures.
-        out = ft.build_escalation_block("clip-a", "x", error_category="z",
-                                         threshold=2, now=t0 + 2)
-        self.assertIsNotNone(out)
-        self.assertEqual(out["failure_count"], 2)
-
-
-if __name__ == "__main__":
-    unittest.main()