@dpantani/tdmcp 0.4.0 → 0.6.1

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

@@ -0,0 +1,213 @@
+"""First-class connect/disconnect — survives TDMCP_BRIDGE_ALLOW_EXEC=0.
+
+Pure functions; reach TD globals via ``import td`` INSIDE each function so the
+module imports cleanly off-TD (mirrors ``mcp/services/api_service.py``). Raise
+``ValueError``/``LookupError``/``IndexError`` on hard failure; the router turns
+them into the standard 400 ``{ok:false,error:{message}}`` envelope.
+
+Connector model (probed live on TD 2025.32820):
+  - ``op.inputConnectors`` / ``op.outputConnectors`` are indexed lists of
+    ``Connector`` objects; an unwired ``noiseTOP`` still exposes its slots.
+  - ``inputConnector.connect(outputConnector | op)`` makes the wire.
+  - ``inputConnector.connections`` lists the upstream OUTPUT connectors; each
+    exposes ``.owner`` (the source op) and ``.index`` (the source output index).
+  - Multi-input TOPs PACK their inputs contiguously: wiring into a non-trailing
+    slot, or removing a middle wire, renumbers the rest. So ``connect`` reports
+    the ``actual_input`` it lands on (re-scanned after the wire), and
+    ``disconnect`` prefers by-source-path filtering over a fixed index.
+
+This module is intentionally flat and self-contained: the integrator drops it in
+as ``mcp/services/connect_service.py`` unchanged.
+"""
+
+
+def _resolve(op, path):
+    node = op(path)
+    if node is None:
+        raise LookupError(path)
+    return node
+
+
+def _same_parent(src, dst):
+    src_parent = src.parent()
+    dst_parent = dst.parent()
+    if src_parent is None or dst_parent is None:
+        return False
+    return src_parent.path == dst_parent.path
+
+
+def _src_owner(connection):
+    """The source op behind an upstream output connector.
+
+    ``.owner`` is the probed attribute; ``.op`` is a harmless legacy fallback.
+    """
+    owner = getattr(connection, "owner", None)
+    if owner is not None:
+        return owner
+    return getattr(connection, "op", None)
+
+
+def connect(source_path, target_path, source_output=0, target_input=0):
+    """Wire ``source.outputConnectors[source_output]`` ->
+    ``target.inputConnectors[target_input]``.
+
+    Returns the §3.2 dict including the live ``actual_input`` slot (which may
+    differ from ``requested_input`` because multi-input TOPs pack). Raises on
+    not-found / cross-container / connector-index-out-of-range.
+    """
+    import td
+
+    op = td.op
+
+    source_output = int(source_output)
+    target_input = int(target_input)
+
+    src = op(source_path)
+    dst = op(target_path)
+    if src is None or dst is None:
+        raise LookupError(
+            "connect: source or target not found (%s -> %s)" % (source_path, target_path)
+        )
+
+    # 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 not _same_parent(src, dst):
+        raise ValueError(
+            "connect: cannot wire across containers (%s -> %s); use a Select/In OP"
+            % (source_path, target_path)
+        )
+
+    in_connectors = dst.inputConnectors
+    out_connectors = src.outputConnectors
+    if target_input < 0 or target_input >= len(in_connectors):
+        raise IndexError(
+            "connect: target_input %d out of range (%d input connectors on %s)"
+            % (target_input, len(in_connectors), target_path)
+        )
+    if source_output < 0 or source_output >= len(out_connectors):
+        raise IndexError(
+            "connect: source_output %d out of range (%d output connectors on %s)"
+            % (source_output, len(out_connectors), source_path)
+        )
+
+    out_conn = out_connectors[source_output]
+
+    # Snapshot which input slots already carry this exact (src, source_output) wire
+    # BEFORE connecting, so afterwards we can identify the NEW slot. Multi-input TOPs
+    # pack contiguously, and the same source output may already feed another input —
+    # scanning only after the connect could report a pre-existing slot.
+    def _slots_carrying_src():
+        found = set()
+        for ic in dst.inputConnectors:
+            for oc in ic.connections:
+                owner = _src_owner(oc)
+                if owner is not None and owner.path == src.path and oc.index == source_output:
+                    found.add(ic.index)
+        return found
+
+    before = _slots_carrying_src()
+    in_connectors[target_input].connect(out_conn)
+    after = _slots_carrying_src()
+
+    # The slot that appeared is the one TD actually used (packing may differ from
+    # the requested index). Fall back to the requested index if the diff is empty
+    # (e.g. the wire already existed) or ambiguous.
+    _new = sorted(after - before)
+    actual_input = _new[0] if _new else target_input
+
+    return {
+        "source_path": src.path,
+        "target_path": dst.path,
+        "requested_input": target_input,
+        "actual_input": actual_input,
+        "source_output": source_output,
+        "connected": True,
+    }
+
+
+def disconnect(to_path, from_path=None, to_input=None):
+    """Remove input wire(s) into ``to_path``.
+
+    ``from_path`` ``None`` removes every wire into ``to_path`` (scoped by
+    ``to_input`` if given). Fail-forward: per-wire problems are collected as
+    ``warnings`` rather than raised; only a missing ``to_path`` is fatal.
+    Returns the §3.2 dict ``{to_path, from_path, to_input, removed, warnings}``.
+    """
+    import td
+
+    op = td.op
+
+    if to_input is not None:
+        to_input = int(to_input)
+
+    to = op(to_path)
+    if to is None:
+        raise LookupError("disconnect: node not found: %s" % to_path)
+
+    removed = []
+    warnings = []
+
+    # PASS 1 — snapshot every wire to remove BEFORE mutating anything. On a packing
+    # multi-input op, disconnecting repacks the remaining wires to lower indices, so
+    # iterating the live connectors while disconnecting can skip a wire that just
+    # moved into a slot we already passed. The `connection` (upstream OUTPUT
+    # connector) is stable across repacks, so pass 2 re-finds each wire by it.
+    targets = []  # list of (input_index, connection, src_path)
+    for connector in to.inputConnectors:
+        index = connector.index
+        if to_input is not None and index != to_input:
+            continue
+        try:
+            connections = list(connector.connections)
+        except Exception as exc:  # noqa: BLE001
+            warnings.append("inputConnectors[%d].connections error: %s" % (index, exc))
+            continue
+        for connection in connections:
+            src_op = _src_owner(connection)
+            if src_op is None:
+                warnings.append("Could not resolve upstream op for inputConnectors[%d]" % index)
+                continue
+            if from_path is not None and src_op.path != from_path:
+                continue
+            targets.append((index, connection, src_op.path))
+
+    # PASS 2 — disconnect each snapshotted wire. Re-find the connector that currently
+    # holds it (repacking may have moved it to a lower index) and scope the disconnect
+    # to that one input<-output link; connection.disconnect() would tear down the
+    # source output's wires to EVERY downstream target. Fall back to clearing the
+    # holding input slot (still only affects to_path, never the source's outputs).
+    for index, connection, src_path in targets:
+        holder = None
+        for connector in to.inputConnectors:
+            try:
+                if connection in connector.connections:
+                    holder = connector
+                    break
+            except Exception:  # noqa: BLE001
+                continue
+        if holder is None:
+            # Already gone (removed alongside another wire's repack) — the net effect
+            # we wanted is achieved, so still count it.
+            removed.append({"input": index, "from": src_path})
+            continue
+        try:
+            holder.disconnect(connection)
+            removed.append({"input": index, "from": src_path})
+        except Exception as exc1:  # noqa: BLE001
+            try:
+                holder.disconnect()
+                removed.append({"input": index, "from": src_path})
+            except Exception as exc2:  # noqa: BLE001
+                warnings.append(
+                    "disconnect failed for inputConnectors[%d] from %s: "
+                    "connector.disconnect(conn) -> %s; connector.disconnect() -> %s"
+                    % (index, src_path, exc1, exc2)
+                )
+
+    return {
+        "to_path": to.path,
+        "from_path": from_path,
+        "to_input": to_input,
+        "removed": removed,
+        "warnings": warnings,
+    }

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

@@ -0,0 +1,136 @@
+"""GET /api/logs — read the bridge Error DAT's structured cook errors/warnings.
+
+Survives TDMCP_BRIDGE_ALLOW_EXEC=0 (it is a read endpoint, not exec). Reads the
+bridge's Error DAT rows instead of char-iterating `op.errors()` (which returns a
+STRING, not a list — the legacy walk's latent bug).
+
+Error DAT columns (confirmed live): source | message | absframe | frame |
+severity | type. We map columns BY HEADER NAME (row 0), not by fixed index, so a
+future column reorder can't silently misalign the data (§7-R6). Falls back to
+{available: False, ...} when the Error DAT is missing (older bridge) so the
+client can use the legacy op-walk.
+
+Pure module of top-level functions. `op` is bound from `td` at import time
+(mirroring api_service.py) so the module imports cleanly off-TD and the test
+harness can patch `op` per-test.
+"""
+
+import td
+
+op = td.op
+
+# Canonical column names we surface, in their confirmed live order. Used as a
+# fallback when a header row is absent or unrecognized.
+_EXPECTED_COLUMNS = ("source", "message", "absframe", "frame", "severity", "type")
+_INT_COLUMNS = ("absframe", "frame")
+
+
+def _cell(dat, row, col):
+    """Read dat[row, col] as a plain string, tolerating Cell wrappers."""
+    try:
+        return str(dat[row, col])
+    except Exception:  # noqa: BLE001
+        return ""
+
+
+def _header_map(dat):
+    """Map column NAME -> column index from row 0.
+
+    Falls back to the expected fixed order if a header cell is blank or the row
+    is unreadable. Keying by name (not [0..5]) is cheap insurance against a
+    column reorder (§7-R6).
+    """
+    mapping = {}
+    num_cols = int(getattr(dat, "numCols", 0) or 0)
+    for col in range(num_cols):
+        name = _cell(dat, 0, col).strip().lower()
+        if name:
+            mapping[name] = col
+    # If the header was missing/garbled, fall back to positional expectations so
+    # we still return useful rows.
+    if not mapping:
+        for idx, name in enumerate(_EXPECTED_COLUMNS):
+            if idx < num_cols:
+                mapping[name] = idx
+    return mapping
+
+
+def get_logs(
+    severity="all",
+    max_lines=200,
+    scope=None,
+    error_dat_path="/project1/tdmcp_bridge/error_log",
+):
+    """Read the bridge Error DAT's rows.
+
+    Returns {lines, count, error_dat, available, warnings}. `scope` filters by a
+    `source` path prefix when provided (the Error DAT's own `fromop` already
+    bounds capture; this is an extra client-side narrowing). Severity is one of
+    all|error|warning. Newest rows are near the bottom, so we keep the LAST
+    max_lines after filtering.
+    """
+    report = {
+        "lines": [],
+        "count": 0,
+        "error_dat": error_dat_path,
+        "available": True,
+        "warnings": [],
+    }
+    dat = op(error_dat_path)  # noqa: F821 - TD global
+    if dat is None:
+        report["available"] = False
+        report["warnings"].append(
+            "Error DAT not found at %s; reinstall the bridge to enable structured "
+            "logs (falling back to the op-walk)." % error_dat_path
+        )
+        return report
+
+    num_rows = int(getattr(dat, "numRows", 0) or 0)
+    if num_rows <= 1:
+        # Header only (or empty) — no captured rows yet.
+        return report
+
+    header = _header_map(dat)
+    want_sev = str(severity or "all").strip().lower()
+    scope_prefix = str(scope).rstrip("/") if scope else None
+
+    lines = []
+    # Skip row 0 (header); iterate data rows in append order (newest near bottom).
+    for row in range(1, num_rows):
+        entry = {}
+        for name, col in header.items():
+            if name not in _EXPECTED_COLUMNS:
+                continue
+            raw = _cell(dat, row, col)
+            if name in _INT_COLUMNS:
+                try:
+                    entry[name] = int(raw)
+                except Exception:  # noqa: BLE001
+                    pass  # leave it out rather than emit a bogus int
+            else:
+                entry[name] = raw
+        # severity filter
+        if want_sev in ("error", "warning"):
+            if str(entry.get("severity", "")).strip().lower() != want_sev:
+                continue
+        # optional scope (source path prefix) filter
+        if scope_prefix:
+            src = str(entry.get("source", ""))
+            if not (src == scope_prefix or src.startswith(scope_prefix + "/")):
+                continue
+        lines.append(entry)
+
+    # Keep the newest N (rows are append-order, newest last).
+    try:
+        cap = int(max_lines)
+    except Exception:  # noqa: BLE001
+        cap = 200
+    if cap > 0 and len(lines) > cap:
+        report["warnings"].append(
+            "Truncated to %d of %d matching rows (newest kept)." % (cap, len(lines))
+        )
+        lines = lines[-cap:]
+
+    report["lines"] = lines
+    report["count"] = len(lines)
+    return report

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

@@ -0,0 +1,218 @@
+"""Param-mode + DAT-text endpoints — survive TDMCP_BRIDGE_ALLOW_EXEC=0.
+
+Promote reactive authoring (parameter mode / expression / bind / constant) and
+whole-text DAT editing off `/api/exec` so they keep working when arbitrary code
+execution is disabled in TouchDesigner.
+
+Pure module of top-level functions taking primitives. `op` is bound from `td`
+at import time (mirroring mcp/services/api_service.py) so the module imports
+cleanly off-TD and the test harness can patch `op` per-test. Hard failures raise
+ValueError / LookupError; the router turns them into the 400 envelope.
+
+ParMode is NOT importable as `td.ParMode` or a bare global (confirmed live —
+all three import forms raise). Resolve the enum class from a LIVE parameter:
+`ModeCls = type(par.mode)` then `ModeCls.EXPRESSION / .BIND / .CONSTANT /
+.EXPORT`. (`tdutils.TDDefinitions.ParMode` is the real home if ever needed.)
+This also fixes the latent bug where `_par.mode = ParMode.EXPRESSION` silently
+fell into an except branch every time.
+"""
+
+import math
+
+import td
+
+# TouchDesigner injects globals (op, ParMode, operator classes) only into
+# DAT/Textport scope, not into imported modules — so reach them via `td`.
+op = td.op
+
+
+def _json_safe(value):
+    """Coerce a parameter value into something json.dumps can serialize."""
+    if value is None or isinstance(value, (str, bool)):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return value if math.isfinite(value) else str(value)
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(v) for v in value]
+    if isinstance(value, dict):
+        return {str(k): _json_safe(v) for k, v in value.items()}
+    try:
+        _path = getattr(value, "path", None)
+        if _path is not None:
+            return str(_path)
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        return str(value)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _normalize_mode(par):
+    """Return the UPPER mode name (CONSTANT/EXPRESSION/EXPORT/BIND) for a Par."""
+    try:
+        _raw = par.mode
+    except Exception:  # noqa: BLE001
+        return "UNKNOWN"
+    if _raw is None:
+        return "UNKNOWN"
+    # par.mode.name is the clean enum name; fall back to str().split() parsing.
+    name = getattr(_raw, "name", None)
+    if name:
+        return str(name).upper()
+    return str(_raw).split(".")[-1].upper()
+
+
+def read_param_modes(path, keys=None, non_default_only=False):
+    """Report each parameter's mode + value + expression strings.
+
+    Returns {path, type, name, parameters:[{name, mode, value?, expr?,
+    bind_expr?, export_op?}], warnings}. Raises LookupError if the node is
+    missing so the router answers 400.
+    """
+    node = op(path)  # noqa: F821 - TD global
+    if node is None:
+        raise LookupError("Node not found: %s" % path)
+    report = {
+        "path": path,
+        "type": getattr(node, "type", "") or "",
+        "name": getattr(node, "name", "") or "",
+        "parameters": [],
+        "warnings": [],
+    }
+    _keys = set(keys) if keys else None
+    for par in node.pars():
+        try:
+            pname = par.name
+            if _keys is not None and pname not in _keys:
+                continue
+            mode = _normalize_mode(par)
+            if non_default_only and mode == "CONSTANT":
+                continue
+            entry = {"name": pname, "mode": mode}
+            try:
+                entry["value"] = _json_safe(par.eval())
+            except Exception as exc:  # noqa: BLE001
+                report["warnings"].append("Could not eval %s: %s" % (pname, exc))
+            try:
+                _expr = par.expr
+                if _expr:
+                    entry["expr"] = str(_expr)
+            except Exception:  # noqa: BLE001
+                pass
+            try:
+                _be = getattr(par, "bindExpr", "")
+                if _be:
+                    entry["bind_expr"] = str(_be)
+            except Exception:  # noqa: BLE001
+                pass
+            try:
+                _eop = par.exportOP
+                if _eop is not None:
+                    entry["export_op"] = _eop.path
+            except Exception:  # noqa: BLE001
+                pass
+            report["parameters"].append(entry)
+        except Exception as exc:  # noqa: BLE001
+            report["warnings"].append("Error reading parameter: %s" % exc)
+    return report
+
+
+def set_param_mode(path, param, mode, expr=None, value=None):
+    """Set one parameter's mode to expression / bind / constant.
+
+    Uses ModeCls = type(par.mode) for the enum (ParMode is not importable).
+    Returns {path, param, mode, readback_mode, readback_expr}. Raises on
+    not-found / unknown param / missing expr / bad value.
+    """
+    node = op(path)  # noqa: F821 - TD global
+    if node is None:
+        raise LookupError("Node not found: %s" % path)
+    par = getattr(node.par, param, None)
+    if par is None:
+        raise ValueError("No such parameter: %s on %s" % (param, path))
+
+    # Resolve the ParMode enum class from a live parameter — ParMode is NOT a
+    # bare global / td.ParMode. This is the robust path AND the bug fix.
+    mode_cls = type(par.mode)
+
+    norm = str(mode or "expression").strip().lower()
+    if norm == "expression":
+        if not expr:
+            raise ValueError("expr is required for mode 'expression' (param %s)" % param)
+        par.expr = expr
+        par.mode = mode_cls.EXPRESSION
+    elif norm == "bind":
+        if not expr:
+            raise ValueError("expr is required for mode 'bind' (param %s)" % param)
+        par.bindExpr = expr
+        par.mode = mode_cls.BIND
+    elif norm == "constant":
+        if value is None:
+            raise ValueError("value is required for mode 'constant' (param %s)" % param)
+        par.val = value
+        par.mode = mode_cls.CONSTANT
+    else:
+        raise ValueError("Unknown mode %r (expected expression|bind|constant)" % mode)
+
+    # Read back from the attribute that matches the mode just written: bind lives in
+    # par.bindExpr, expression in par.expr; a constant has no expression (par.expr may
+    # hold a stale one, so report empty rather than something misleading).
+    readback_expr = ""
+    try:
+        if norm == "bind":
+            readback_expr = str(getattr(par, "bindExpr", "") or "")
+        elif norm == "expression":
+            readback_expr = str(getattr(par, "expr", "") or "")
+    except Exception:  # noqa: BLE001
+        readback_expr = ""
+    return {
+        "path": path,
+        "param": param,
+        "mode": norm,
+        "readback_mode": _normalize_mode(par),
+        "readback_expr": readback_expr,
+    }
+
+
+def is_dat(path):
+    """True when ``path`` resolves to a DAT. Used to disambiguate the ``…/text``
+    route from a node literally named ``text``: the WebServer DAT decodes %2F, so the
+    router cannot tell a 'text' endpoint suffix from a 'text' node name by shape."""
+    return bool(getattr(op(path), "isDAT", False))  # noqa: F821 - TD global
+
+
+def get_dat_text(path):
+    """Return {path, text, is_table, num_rows, num_cols} for a DAT.
+
+    Raises LookupError if the node is missing, ValueError if it is not a DAT.
+    """
+    node = op(path)  # noqa: F821 - TD global
+    if node is None:
+        raise LookupError("Node not found: %s" % path)
+    if not getattr(node, "isDAT", False):
+        raise ValueError("%s is not a DAT." % path)
+    return {
+        "path": path,
+        "text": node.text,
+        "is_table": bool(getattr(node, "isTable", False)),
+        "num_rows": int(getattr(node, "numRows", 0) or 0),
+        "num_cols": int(getattr(node, "numCols", 0) or 0),
+    }
+
+
+def put_dat_text(path, text):
+    """Overwrite a DAT's whole `.text`. Returns {path, old_length, new_length}.
+
+    Raises LookupError if the node is missing, ValueError if it is not a DAT.
+    """
+    node = op(path)  # noqa: F821 - TD global
+    if node is None:
+        raise LookupError("Node not found: %s" % path)
+    if not getattr(node, "isDAT", False):
+        raise ValueError("%s is not a DAT." % path)
+    old_length = len(node.text)
+    node.text = text
+    return {"path": path, "old_length": old_length, "new_length": len(text)}

package/td/modules/utils/version.py

@@ -1,3 +1,3 @@
 """Version of the tdmcp TouchDesigner bridge."""
 
-BRIDGE_VERSION = "0.4.0"
+BRIDGE_VERSION = "0.6.1"