@dpantani/tdmcp 0.1.0 → 0.2.0

package/td/modules/mcp/services/batch_service.py

@@ -11,8 +11,42 @@ def connect(source_path, target_path, source_output=0, target_input=0):
     src = op(source_path)
     dst = op(target_path)
     if src is None or dst is None:
-        raise LookupError("Source or target not found")
-    dst.inputConnectors[target_input].connect(src.outputConnectors[source_output])
+        raise LookupError("Source or target not found: %s -> %s" % (source_path, target_path))
+    src_parent = src.parent()
+    dst_parent = dst.parent()
+    # TD wires only connect operators sharing a parent. A cross-container connect
+    # silently no-ops (no exception, no wire), so reject it with an actionable msg.
+    if src_parent is None or dst_parent is None or src_parent.path != dst_parent.path:
+        raise ValueError(
+            "Cannot wire across containers: %s (in %s) -> %s (in %s). "
+            "Wires only connect operators sharing a parent; to bring an operator "
+            "across networks use a Select/In OP (e.g. a Select TOP/CHOP whose source "
+            "parameter points at %r)."
+            % (
+                src.path,
+                getattr(src_parent, "path", "<root>"),
+                dst.path,
+                getattr(dst_parent, "path", "<root>"),
+                source_path,
+            )
+        )
+    try:
+        in_conn = dst.inputConnectors[target_input]
+        out_conn = src.outputConnectors[source_output]
+    except IndexError:
+        raise IndexError(
+            "Connector index out of range: target_input=%d (%s has %d input(s)), "
+            "source_output=%d (%s has %d output(s))."
+            % (
+                target_input,
+                dst.path,
+                len(dst.inputConnectors),
+                source_output,
+                src.path,
+                len(src.outputConnectors),
+            )
+        )
+    in_conn.connect(out_conn)
 
 
 def run(operations):

package/td/modules/mcp/services/preview_service.py

@@ -1,4 +1,10 @@
-"""Capture a TOP as a base64-encoded PNG."""
+"""Capture a TOP as a base64-encoded PNG.
+
+The TOP is composited over a checkerboard first, so transparent regions read as a
+checker pattern instead of solid white when a viewer flattens the PNG's alpha over a
+white page. Opaque TOPs are unaffected (the checker stays fully hidden). If the
+composite path errors for any reason, we fall back to saving the TOP directly.
+"""
 
 import base64
 
@@ -6,14 +12,18 @@ import td
 
 op = td.op  # TD globals are not available inside imported modules; reach via td
 
+# Mid-gray checkerboard (16x9 cells). Self-contained fragment shader, no inputs/uniforms.
+_CHECKER_FRAG = """out vec4 fragColor;
+void main(){
+    vec2 cell = floor(vUV.st * vec2(16.0, 9.0));
+    float k = mod(cell.x + cell.y, 2.0);
+    fragColor = vec4(mix(vec3(0.16), vec3(0.30), k), 1.0);
+}
+"""
 
-def capture(path, width=640, height=360):
-    node = op(path)
-    if node is None:
-        raise LookupError("Node not found: %s" % path)
-    if getattr(node, "family", None) != "TOP":
-        raise ValueError("Preview is only supported for TOPs, got %s" % path)
 
+def _save_png(node):
+    """Return the node's PNG bytes, via saveByteArray with a temp-file fallback."""
     data = None
     try:
         data = node.saveByteArray(".png")
@@ -21,7 +31,6 @@ def capture(path, width=640, height=360):
         data = None
 
     if data is None:
-        # Fallback: save to a temp file and read it back.
         import os
         import tempfile
 
@@ -30,11 +39,75 @@ def capture(path, width=640, height=360):
         with open(tmp, "rb") as handle:
             data = handle.read()
 
-    encoded = base64.b64encode(bytes(data)).decode("ascii")
+    return bytes(data)
+
+
+def _checkerboard_png(node, width, height):
+    """Composite `node` over a checkerboard and return the flattened PNG bytes.
+
+    Creates a few temporary nodes in the node's parent and destroys them afterwards
+    (even on error). Returns None if the composite could not be produced, so callers
+    can fall back to a direct save.
+    """
+    parent = node.parent()
+    if parent is None:
+        return None
+
+    temps = []
+    try:
+        frag = parent.create("textDAT", "__tdmcp_pv_frag")
+        temps.append(frag)
+        frag.text = _CHECKER_FRAG
+
+        bg = parent.create("glslTOP", "__tdmcp_pv_bg")
+        temps.append(bg)
+        bg.par.pixeldat = frag.name
+        bg.par.outputresolution = "custom"
+        bg.par.resolutionw = width
+        bg.par.resolutionh = height
+
+        comp = parent.create("compositeTOP", "__tdmcp_pv_comp")
+        temps.append(comp)
+        comp.par.operand = "over"
+        comp.par.outputresolution = "custom"
+        comp.par.resolutionw = width
+        comp.par.resolutionh = height
+        comp.inputConnectors[0].connect(node)  # foreground (over)
+        comp.inputConnectors[1].connect(bg)  # background (under)
+        comp.cook(force=True)
+
+        if comp.errors():
+            return None
+        return _save_png(comp)
+    except Exception:  # noqa: BLE001
+        return None
+    finally:
+        for t in reversed(temps):
+            try:
+                t.destroy()
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def capture(path, width=640, height=360):
+    node = op(path)
+    if node is None:
+        raise LookupError("Node not found: %s" % path)
+    if getattr(node, "family", None) != "TOP":
+        raise ValueError("Preview is only supported for TOPs, got %s" % path)
+
+    w = int(getattr(node, "width", width) or width)
+    h = int(getattr(node, "height", height) or height)
+
+    data = _checkerboard_png(node, w, h)
+    if data is None:
+        data = _save_png(node)
+
+    encoded = base64.b64encode(data).decode("ascii")
     return {
         "path": node.path,
-        "width": int(getattr(node, "width", width) or width),
-        "height": int(getattr(node, "height", height) or height),
+        "width": w,
+        "height": h,
         "format": "png",
         "base64": encoded,
     }

package/td/tests/test_api_controller.py

@@ -202,6 +202,40 @@ class ParsingTests(unittest.TestCase):
         self.assertIsNone(ac._find_header({"other": "v"}, "x-token"))
 
 
+class OriginTests(unittest.TestCase):
+    """The Origin guard blocks browser-driven CSRF / DNS-rebinding."""
+
+    def test_no_origin_is_allowed(self):
+        ac._check_origin({"method": "GET"})  # the Node client sends no Origin
+
+    def test_loopback_origins_allowed(self):
+        for origin in (
+            "http://127.0.0.1:9980",
+            "http://localhost",
+            "https://localhost:3000",
+            "http://[::1]:9980",
+        ):
+            ac._check_origin({"Origin": origin})  # must not raise
+
+    def test_cross_origin_rejected(self):
+        for origin in ("http://evil.com", "https://attacker.example:8443", "http://192.168.1.5"):
+            with self.assertRaises(PermissionError, msg=origin):
+                ac._check_origin({"Origin": origin})
+
+    def test_opaque_null_origin_rejected(self):
+        with self.assertRaises(PermissionError):
+            ac._check_origin({"Origin": "null"})
+
+    def test_origin_lookup_is_case_insensitive_and_nested(self):
+        with self.assertRaises(PermissionError):
+            ac._check_origin({"headers": {"origin": "http://evil.com"}})
+
+    def test_handle_rejects_cross_origin_with_401(self):
+        resp = ac.handle({"method": "GET", "uri": "/api/info", "Origin": "http://evil.com"}, {})
+        self.assertEqual(resp["statusCode"], 401)
+        self.assertIn("cross-origin", resp["data"])
+
+
 class HandleTests(unittest.TestCase):
     def tearDown(self):
         _clear_exec_env()

package/td/tests/test_services.py

@@ -0,0 +1,209 @@
+"""Unit tests for the bridge service layer: parameter validation + connect guards.
+
+Exercises api_service.update_parameters / create_node and batch_service.connect
+off-TD using lightweight fakes for TD node objects. These lock in the fixes for
+two silent-failure bugs:
+
+  * setting an unknown parameter name (e.g. `gain` on a levelTOP) used to be
+    silently dropped; it now raises (update) or warns (create).
+  * wiring two operators in different containers used to silently no-op; it now
+    raises with an actionable message.
+
+Stdlib only. Run: `python3 -m unittest discover -s td/tests` (or `npm run test:bridge`).
+"""
+
+import os
+import sys
+import types
+import unittest
+from unittest import mock
+
+# --- Make the bridge importable without TouchDesigner --------------------------
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_MODULES = os.path.abspath(os.path.join(_HERE, "..", "modules"))
+if _MODULES not in sys.path:
+    sys.path.insert(0, _MODULES)
+
+# `mcp.services.*` bind `op/app/project` from `td` at import time; a stub suffices.
+_td_stub = types.ModuleType("td")
+_td_stub.op = mock.MagicMock(name="op")
+_td_stub.app = mock.MagicMock(name="app")
+_td_stub.project = mock.MagicMock(name="project")
+sys.modules.setdefault("td", _td_stub)
+
+from mcp.services import analysis_service, api_service, batch_service  # noqa: E402
+
+
+# --- Lightweight fakes for TD node objects -------------------------------------
+class FakePar:
+    def __init__(self, name, val=None):
+        self.name = name
+        self.val = val
+
+    def eval(self):
+        return self.val
+
+
+class FakeParCollection:
+    """getattr(self, name, None) -> FakePar for known names, None otherwise."""
+
+    def __init__(self, names):
+        for n in names:
+            setattr(self, n, FakePar(n))
+
+
+class FakeConnector:
+    def __init__(self):
+        self.connected_to = None
+
+    def connect(self, other):
+        self.connected_to = other
+
+
+class FakeNode:
+    def __init__(self, path, par_names=(), parent_path="/project1", n_in=1, n_out=1):
+        self.path = path
+        self.name = path.rsplit("/", 1)[-1]
+        self.OPType = "fakeTOP"
+        self.par = FakeParCollection(par_names)
+        self.inputs = []
+        self.outputs = []
+        self.inputConnectors = [FakeConnector() for _ in range(n_in)]
+        self.outputConnectors = [FakeConnector() for _ in range(n_out)]
+        self._parent_path = parent_path
+
+    def pars(self):
+        return [v for v in vars(self.par).values() if isinstance(v, FakePar)]
+
+    def parent(self):
+        return types.SimpleNamespace(path=self._parent_path)
+
+
+class UpdateParametersTests(unittest.TestCase):
+    def test_rejects_unknown_param_atomically(self):
+        node = FakeNode("/project1/lvl", ["brightness1"])
+        with mock.patch.object(api_service, "op", lambda p: node):
+            with self.assertRaises(ValueError) as cm:
+                api_service.update_parameters("/project1/lvl", {"gain": 0.5, "brightness1": 0.9})
+        self.assertIn("gain", str(cm.exception))
+        # Atomic: a valid sibling param in the same call is NOT applied either.
+        self.assertIsNone(node.par.brightness1.val)
+
+    def test_applies_known_params(self):
+        node = FakeNode("/project1/lvl", ["brightness1", "opacity"])
+        with mock.patch.object(api_service, "op", lambda p: node):
+            detail = api_service.update_parameters(
+                "/project1/lvl", {"brightness1": 0.85, "opacity": 0.5}
+            )
+        self.assertEqual(node.par.brightness1.val, 0.85)
+        self.assertEqual(node.par.opacity.val, 0.5)
+        self.assertEqual(detail["path"], "/project1/lvl")
+
+    def test_missing_node_raises(self):
+        with mock.patch.object(api_service, "op", lambda p: None):
+            with self.assertRaises(LookupError):
+                api_service.update_parameters("/nope", {"x": 1})
+
+
+class CreateNodeWarningTests(unittest.TestCase):
+    def test_failed_params_become_warnings_not_silent(self):
+        node = FakeNode("/project1/lvl", ["brightness1"])
+        parent = mock.MagicMock(name="parent")
+        parent.create.return_value = node
+        with mock.patch.object(api_service, "op", lambda p: parent), mock.patch.object(
+            api_service, "_resolve_type", lambda t: object
+        ):
+            ref = api_service.create_node(
+                "/project1", "fakeTOP", "lvl", {"gain": 1, "brightness1": 0.5}
+            )
+        # Node is still created; the bad param surfaces as a warning, not silence.
+        self.assertEqual(ref["path"], "/project1/lvl")
+        self.assertIn("gain", ref.get("parameter_warnings", []))
+        # The valid param still applied.
+        self.assertEqual(node.par.brightness1.val, 0.5)
+
+    def test_no_warnings_when_all_params_valid(self):
+        node = FakeNode("/project1/lvl", ["brightness1"])
+        parent = mock.MagicMock(name="parent")
+        parent.create.return_value = node
+        with mock.patch.object(api_service, "op", lambda p: parent), mock.patch.object(
+            api_service, "_resolve_type", lambda t: object
+        ):
+            ref = api_service.create_node("/project1", "fakeTOP", "lvl", {"brightness1": 0.5})
+        self.assertNotIn("parameter_warnings", ref)
+
+
+class ConnectGuardTests(unittest.TestCase):
+    def _patch_op(self, nodes):
+        return mock.patch.object(batch_service, "op", lambda p: nodes.get(p))
+
+    def test_rejects_cross_container(self):
+        src = FakeNode("/project1/a/x", parent_path="/project1/a")
+        dst = FakeNode("/project1/b/y", parent_path="/project1/b")
+        with self._patch_op({"/project1/a/x": src, "/project1/b/y": dst}):
+            with self.assertRaises(ValueError) as cm:
+                batch_service.connect("/project1/a/x", "/project1/b/y")
+        self.assertIn("across containers", str(cm.exception))
+        # No phantom wire was made.
+        self.assertIsNone(dst.inputConnectors[0].connected_to)
+
+    def test_same_parent_wires(self):
+        src = FakeNode("/project1/x", parent_path="/project1")
+        dst = FakeNode("/project1/y", parent_path="/project1")
+        with self._patch_op({"/project1/x": src, "/project1/y": dst}):
+            batch_service.connect("/project1/x", "/project1/y")
+        self.assertIs(dst.inputConnectors[0].connected_to, src.outputConnectors[0])
+
+    def test_bad_connector_index_raises(self):
+        src = FakeNode("/project1/x", parent_path="/project1")
+        dst = FakeNode("/project1/y", parent_path="/project1", n_in=1)
+        with self._patch_op({"/project1/x": src, "/project1/y": dst}):
+            with self.assertRaises(IndexError):
+                batch_service.connect("/project1/x", "/project1/y", target_input=3)
+
+    def test_missing_node_raises(self):
+        with self._patch_op({}):
+            with self.assertRaises(LookupError):
+                batch_service.connect("/a", "/b")
+
+
+class _PerfNode:
+    def __init__(self, path, cook_time=0.0, cook_count=0):
+        self.path = path
+        self.cookTime = cook_time
+        self.cookCount = cook_count
+
+
+class _PerfRoot:
+    """Returns direct children at depth=1, all descendants otherwise — like a TD COMP."""
+
+    def __init__(self, direct, nested):
+        self._direct = direct
+        self._nested = nested
+
+    def findChildren(self, depth=None):
+        return self._direct if depth == 1 else self._nested
+
+
+class PerformanceRecursiveTests(unittest.TestCase):
+    def _run(self, recursive):
+        direct = [_PerfNode("/p/a", 1.0)]
+        nested = [_PerfNode("/p/a", 1.0), _PerfNode("/p/sys/inner", 2.0)]
+        root = _PerfRoot(direct, nested)
+        with mock.patch.object(analysis_service, "op", lambda path: root):
+            return analysis_service.performance("/p", recursive=recursive)
+
+    def test_shallow_measures_only_direct_children(self):
+        result = self._run(recursive=False)
+        self.assertEqual([n["path"] for n in result["nodes"]], ["/p/a"])
+        self.assertEqual(result["total_cook_time_ms"], 1.0)
+
+    def test_recursive_measures_nested_nodes_too(self):
+        result = self._run(recursive=True)
+        self.assertEqual(sorted(n["path"] for n in result["nodes"]), ["/p/a", "/p/sys/inner"])
+        # Nested node's cook time is now counted in the total.
+        self.assertEqual(result["total_cook_time_ms"], 3.0)
+
+
+if __name__ == "__main__":
+    unittest.main()