@codesys/mcp-toolkit 2.5.0 → 2.7.0

package/watcher/mcp_caps.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+# Which optional features this CODESYS offers. Several actions rely on CODESYS's
+# services beyond its documented scripting API, or on add-ons (visualization, alarm
+# management). Each check reaches the service the same way its module does, so a
+# feature reported available is one that action can use.
+#
+# Keep this file ASCII-only (IronPython 2.7 inside CODESYS).
+import os
+
+import mcp_ops
+from mcp_ops import _safe
+
+import scriptengine as se
+
+
+def _type(name):
+    from System import AppDomain
+    for a in AppDomain.CurrentDomain.GetAssemblies():
+        try:
+            t = a.GetType(name)
+        except Exception:
+            t = None
+        if t is not None:
+            return t
+    return None
+
+
+def _assembly(name):
+    from System import AppDomain
+    for a in AppDomain.CurrentDomain.GetAssemblies():
+        if a.GetName().Name == name:
+            return True
+    return False
+
+
+def _check(fn):
+    try:
+        return bool(fn())
+    except Exception:
+        return False
+
+
+def op_capabilities(args):
+    import mcp_lang
+    import mcp_debug
+    caps = {
+        "visualization": _check(lambda: hasattr(se, "VisualElementType")),
+        "signatures": _check(lambda: mcp_lang._service("LanguageModelMgr") is not None),
+        "cross_references": _check(lambda: mcp_lang._service("CrossReferenceService") is not None),
+        "debugging": _check(lambda: mcp_debug._bpm() is not None),
+        "trace": _check(lambda: hasattr(se, "trace")),
+        "alarms": _check(lambda: _assembly("AlarmConfigurationObjects.plugin")),
+        "visu_users": _check(lambda: _type("_3S.CoDeSys.VisualObject.VisuUserMgmtLibraryInserter") is not None),
+        "device_repository": _check(lambda: _safe(lambda: se.device_repository) is not None),
+        "library_manager": _check(lambda: getattr(se, "librarymanager", None) is not None),
+        "editor_window": os.environ.get("CODESYS_MCP_UI") == "1",
+    }
+    fpu = None
+    glm = getattr(se, "librarymanager", None)
+    if glm is not None:
+        fpu = _check(lambda: any((l.title or "").lower() == "floatingpointutils" for l in glm.get_all_libraries()))
+    caps["floating_point_utils"] = fpu
+    return {"capabilities": caps}
+
+
+mcp_ops.OPS["capabilities"] = op_capabilities

package/watcher/mcp_devices.py

@@ -79,5 +79,163 @@ def op_devices_add(args):
     return {"path": c.path_of(dev), "saved": c.save_if(args)}
 
 
+def _param_sets(dev):
+    """(prefix, parameter set) for the device itself and each of its connectors."""
+    out = []
+    ps = _safe(lambda: dev.device_parameters)
+    if ps is not None:
+        out.append(("", ps))
+    conns = _safe(lambda: dev.connectors) or []
+    for i, con in enumerate(conns):
+        hp = _safe(lambda: con.host_parameters)
+        if hp is not None and len(hp):
+            out.append(("c%d/" % i, hp))
+    return out
+
+
+def _walk_elements(prefix, el, depth, out, limit):
+    """Every data element under el, depth-first, keyed by its identifier path."""
+    if len(out) >= limit:
+        return
+    ident = to_text(_safe(lambda: el.identifier, "") or "")
+    key = prefix + ident
+    has_sub = bool(_safe(lambda: el.has_sub_elements, False))
+    item = {
+        "key": key,
+        "name": to_text(_safe(lambda: el.visible_name, "") or ""),
+        "depth": depth,
+    }
+    desc = to_text(_safe(lambda: el.description, "") or "")
+    if desc and desc != item["name"]:
+        item["description"] = desc[:160]
+    unit = to_text(_safe(lambda: el.unit, "") or "")
+    if unit:
+        item["unit"] = unit
+    param = _safe(lambda: el.parameter)
+    if depth == 0 and param is not None:
+        sec = to_text(_safe(lambda: param.section, "") or "")
+        if sec:
+            item["section"] = sec
+        t = to_text(_safe(lambda: param.type_string, "") or "")
+        if t:
+            item["type"] = t
+        acc = to_text(_safe(lambda: param.offline_access_rights, "") or "")
+        if acc:
+            item["access"] = acc
+    ch = to_text(_safe(lambda: el.parameter.channel_type, "") or "")
+    if ch and ch.lower() not in ("none", "0"):
+        item["channel"] = ch
+    if not has_sub:
+        v = _safe(lambda: el.value)
+        if v is not None:
+            item["value"] = to_text(v)
+        d = _safe(lambda: el.default_value)
+        if d:
+            item["default"] = to_text(d)
+        if _safe(lambda: el.is_enumeration, False):
+            item["choices"] = [to_text(_safe(lambda: e.identifier, "")) + (("=" + to_text(e.visible_name)) if _safe(lambda: e.visible_name) else "") for e in (_safe(lambda: el.allowed_values) or [])][:40]
+    if _safe(lambda: el.is_mappable_io, False):
+        m = _safe(lambda: el.io_mapping)
+        if m is not None:
+            item["mapping"] = {
+                "variable": to_text(_safe(lambda: m.variable, "") or ""),
+                "address": to_text(_safe(lambda: m.manual_iec_address, "") or ""),
+                "automatic_address": bool(_safe(lambda: m.automatic_iec_address, True)),
+            }
+    out.append(item)
+    if has_sub:
+        for sub in list(el):
+            _walk_elements(key + "/", sub, depth + 1, out, limit)
+
+
+def _device(c, path):
+    dev = c.resolve(path)
+    if not _safe(lambda: dev.is_device, False):
+        raise OpError("bad_path", "%s is not a device (get_devices lists them)." % path)
+    return dev
+
+
+def op_devices_params(args):
+    c = Ctx()
+    dev = _device(c, args["path"])
+    limit = int(args.get("limit") or 600)
+    out = []
+    for prefix, ps in _param_sets(dev):
+        for p in ps:
+            _walk_elements(prefix, p, 0, out, limit)
+    return {"path": c.path_of(dev), "parameters": out, "truncated": len(out) >= limit}
+
+
+def _element(dev, key):
+    """The data element with this key (as devices.params gives it)."""
+    sets = dict(_param_sets(dev))
+    prefix = ""
+    rest = key
+    if key.startswith("c") and "/" in key and key.split("/")[0][1:].isdigit():
+        prefix = key.split("/")[0] + "/"
+        rest = key[len(prefix):]
+    ps = sets.get(prefix)
+    if ps is None:
+        raise OpError("not_found", "No parameter set '%s' on this device." % (prefix or "device"))
+    parts = rest.split("/")
+    el = None
+    for p in ps:
+        if to_text(_safe(lambda: p.identifier, "")) == parts[0]:
+            el = p
+            break
+    if el is None:
+        raise OpError("not_found", "No parameter '%s' (device_parameters lists the keys)." % key)
+    for part in parts[1:]:
+        nxt = None
+        for sub in list(el):
+            if to_text(_safe(lambda: sub.identifier, "")) == part:
+                nxt = sub
+                break
+        if nxt is None:
+            raise OpError("not_found", "No element '%s' in parameter '%s'." % (part, key))
+        el = nxt
+    return el
+
+
+def op_devices_configure(args):
+    c = Ctx()
+    dev = _device(c, args["path"])
+    done = []
+    errors = []
+    for v in args.get("values") or []:
+        try:
+            el = _element(dev, v["key"])
+            val = to_text(v["value"])
+            if _safe(lambda: el.is_enumeration, False):
+                match = None
+                for e in el.allowed_values or []:
+                    if val in (to_text(e.identifier), to_text(_safe(lambda: e.visible_name, "")), to_text(_safe(lambda: e.value, ""))):
+                        match = e
+                        break
+                if match is None:
+                    raise OpError("bad_value", "'%s' isn't one of %s" % (val, ", ".join(to_text(e.identifier) for e in el.allowed_values)))
+                el.enum_value = match
+            else:
+                el.value = val
+            done.append({"key": v["key"], "value": to_text(_safe(lambda: el.value, val))})
+        except Exception as e:
+            errors.append({"key": v.get("key"), "error": to_text(e)[:200]})
+    for m in args.get("mappings") or []:
+        try:
+            el = _element(dev, m["key"])
+            if not _safe(lambda: el.is_mappable_io, False):
+                raise OpError("bad_value", "'%s' is not an I/O channel." % m["key"])
+            io = el.io_mapping
+            io.variable = to_text(m.get("variable") or "")
+            if "address" in m:
+                io.manual_iec_address = to_text(m["address"]) if m["address"] else None
+            done.append({"key": m["key"], "variable": to_text(_safe(lambda: io.variable, "")), "address": to_text(_safe(lambda: io.manual_iec_address, "") or "")})
+        except Exception as e:
+            errors.append({"key": m.get("key"), "error": to_text(e)[:200]})
+    return {"path": c.path_of(dev), "done": done, "errors": errors, "saved": c.save_if(args)}
+
+
+mcp_ops.OPS["devices.params"] = op_devices_params
+mcp_ops.OPS["devices.configure"] = mcp_sim._locked(op_devices_configure)
 mcp_ops.OPS["devices.search"] = op_devices_search
 mcp_ops.OPS["devices.add"] = mcp_sim._locked(op_devices_add)

package/watcher/mcp_lang.py

@@ -101,7 +101,19 @@ def _signature(lmm, c, sig):
     ins = set(to_text(_get(v, "OrgName")) for v in (_get(sig, "Inputs") or []))
     outs = set(to_text(_get(v, "OrgName")) for v in (_get(sig, "Outputs") or []))
     variables = []
-    for v in lmm.GetAllVariables(sig, c.app.guid):
+    found = list(lmm.GetAllVariables(sig, c.app.guid) or [])
+    if not found:
+        # A method of a library FB: the language model keeps its variables on the signature.
+        for prop in ("All", "Variables", "AllVariables"):
+            vs = _get(sig, prop)
+            if vs:
+                try:
+                    found = list(vs)
+                except Exception:
+                    found = []
+                if found:
+                    break
+    for v in found:
         n = to_text(_get(v, "OrgName"))
         variables.append(_var(v, "input" if n in ins else "output" if n in outs else "other"))
     subs = []

package/watcher/mcp_visu.py

@@ -198,6 +198,51 @@ def _script_element(visu, eid):
     return None
 
 
+def _editor_context(c, visu, cache):
+    """The open visual editor's element context for this visualization (needs CODESYS's window)."""
+    if "ctx" in cache:
+        return cache["ctx"]
+    import os
+    if os.environ.get("CODESYS_MCP_UI") != "1":
+        raise OpError("unavailable", "needs CODESYS's window (start with --show-window)")
+    from System.Reflection import BindingFlags
+    from System import Guid
+    allf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static
+    eng = _static("_3S.CoDeSys.VisualEditor.APEnvironment", "Engine")
+    frame = getattr(eng, "Frame", None) if eng is not None else None
+    if frame is None:
+        raise OpError("unavailable", "needs CODESYS's window (start with --show-window)")
+    view = frame.OpenEditorView(_object_mgr().GetMetaObjectStub(c.proj.handle, visu.guid), Guid.Empty, None)
+    se.system.delay(800)
+    ctl = view.Control
+    ve = ctl.GetType().GetField("_visualEditor", allf).GetValue(ctl)
+    ctx = ve.GetType().GetField("_editorCtx", allf).GetValue(ve)
+    vom = _find_type("_3S.CoDeSys.VisualEditor.VisualObjectManager").GetProperty("Singleton", allf).GetValue(None, None)
+    cache["ctx"] = (ctx, vom)
+    return cache["ctx"]
+
+
+def _complex_element(c, visu, el, label, cache):
+    ctx, vom = _editor_context(c, visu, cache)
+    mgr = _object_mgr()
+    mo = mgr.GetObjectToModify(c.proj.handle, visu.guid)
+    ok = False
+    try:
+        vo = mo.Object
+        nid = vo.UniqueId
+        elem = vom.CreateElementByTypeName(el["type_name"], None, label, nid, ctx, True, ctx.AvailableHotkeysProvider, ctx.HotkeysConfiguration)
+        elem.Id = nid
+        elem.OwningObjectGuid = vo.MetaObject.ObjectGuid
+        vo.VisualElemList.Add(elem)
+        ok = True
+    finally:
+        mgr.SetObject(mo, ok, None)
+    e = _script_element(visu, nid)
+    for p, v in (("Position.X", el["x"]), ("Position.Y", el["y"]), ("Position.Width", el["w"]), ("Position.Height", el["h"])):
+        e.set_property(p, int(v))
+    return e
+
+
 def _find_child(c, name):
     for ch in c.app.get_children(False):
         if name_of(ch).lower() == name.lower():
@@ -234,8 +279,28 @@ def op_visu_build(args):
             warnings.append("size/dialog: %s" % to_text(ex))
     T = se.VisualElementType
     corners = []
-    for i, el in enumerate(args.get("elements") or []):
+    queue = list(args.get("elements") or [])
+    editor = {}
+    i = -1
+    while queue:
+        el = queue.pop(0)
+        i += 1
         label = el.get("name") or "E%d" % i
+        if el["kind"] == "complex":
+            # Meters, bar displays and alarm tables need the visual editor's context, which only
+            # exists with CODESYS's window. Without it, the plan's fallback elements are drawn.
+            try:
+                e = _complex_element(c, visu, el, label, editor)
+            except Exception as ex:
+                warnings.append("%s: drawn without %s (%s)" % (label, el.get("type_name"), to_text(ex)[:160]))
+                queue = list(el.get("fallback") or []) + queue
+                continue
+            for pair in el.get("pairs") or []:
+                try:
+                    e.set_property(pair[0], _value(pair[1]))
+                except Exception as ex:
+                    warnings.append("%s %s: %s" % (label, pair[0], to_text(ex)[:120]))
+            continue
         try:
             if el["kind"] in _SIMPLE:
                 eid = _add_created(c.proj, visu, _simple_creator(el), label)
@@ -415,7 +480,22 @@ def op_visu_render(args):
     return {"path": path}
 
 
+def op_ui_open(args):
+    """With CODESYS's window: open an object in its editor (brings its tab forward)."""
+    import os
+    import mcp_ui
+    if os.environ.get("CODESYS_MCP_UI") != "1":
+        raise OpError("unavailable", "CODESYS runs without its window. Start the toolkit with --show-window to see objects in CODESYS.")
+    c = Ctx()
+    obj = c.resolve(args["path"])
+    state = mcp_ui.open_editor(se, obj)
+    if state == "unavailable":
+        raise OpError("unavailable", "This CODESYS doesn't let scripts open editors.")
+    return {"path": c.path_of(obj), "opened": state}
+
+
 mcp_ops.OPS.update({
+    "ui.open": op_ui_open,
     "visu.manager": op_visu_manager,
     "visu.build": op_visu_build,
     "visu.render": op_visu_render,

package/watcher/watcher.py

@@ -260,6 +260,7 @@ def main(ui=False):
     import mcp_debug  # noqa: F401 (adds breakpoints and stepping)
     import mcp_devices  # noqa: F401 (adds device search and add)
     import mcp_alarms  # noqa: F401 (adds alarm management and visu user groups)
+    import mcp_caps  # noqa: F401 (adds the capability check)
     prompts = setup_prompts(se)
     log(prompts)
     if not hasattr(se, "FAKE"):
@@ -311,6 +312,7 @@ def main_attach():
     import mcp_debug  # noqa: F401 (adds breakpoints and stepping)
     import mcp_devices  # noqa: F401 (adds device search and add)
     import mcp_alarms  # noqa: F401 (adds alarm management and visu user groups)
+    import mcp_caps  # noqa: F401 (adds the capability check)
     prompts = setup_prompts(se)
     log(prompts)
     old = getattr(__builtin__, "_mcp_attach_timer", None)