sylo-plc-comms 0.1.0 → 0.1.1

package/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+# Publishes to npm via Trusted Publishing (OIDC — no tokens).
+# npm side: package Settings -> Trusted publishing -> GitHub Actions ->
+#   user Yeti-Trix, this repo, workflow filename publish.yml.
+# Release flow: bump package.json version -> commit -> tag vX.Y.Z -> push tag.
+# Provenance attestations are generated automatically (public repo + package).
+name: Publish Package
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+          package-manager-cache: false
+      - run: npm install
+      - run: npm run build --if-present
+      - run: npm publish

package/package.json

@@ -1,18 +1,11 @@
 {
   "name": "sylo-plc-comms",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "PLC comms layer for Studio 5000/Logix — CIP (EtherNet/IP via ciplogix, vendored wheel) controller info + tag reads/writes, and OPC UA (asyncua) browse/read/write. No Logix Designer SDK required.",
   "type": "module",
   "keywords": [
     "pi-package"
   ],
-  "files": [
-    "extensions",
-    "scripts",
-    "vendor",
-    "README.md",
-    "LICENSE"
-  ],
   "scripts": {},
   "pi": {
     "extensions": [
@@ -25,5 +18,30 @@
   "dependencies": {
     "typebox": "^1.1.24"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "gitHead": "f05700bce9bf8ef8574894f24a8a3fa71da11d61",
+  "dist": {
+    "integrity": "sha512-si9tNTSgo3t/duu+NPOb/8FU5G1W/KIQy+h8ezECT1ZVygbWaRMU0QbXuM/pDYTkw68CaLa1FD1bePM40auSZw==",
+    "shasum": "228315947b4eafd4a30fdfd18574ba4431222fa1",
+    "tarball": "https://registry.npmjs.org/sylo-plc-comms/-/sylo-plc-comms-0.1.0.tgz",
+    "fileCount": 33,
+    "unpackedSize": 198528,
+    "signatures": [
+      {
+        "keyid": "SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U",
+        "sig": "MEYCIQDab2Ulido+eQYehFyzwIKHtqKLVROZc38XxWkLcD6naAIhAMGzRvKAGq/+jfbyvMc1nolb3bhqM4p6taY3Ri2PCb/d"
+      }
+    ]
+  },
+  "directories": {},
+  "maintainers": [
+    {
+      "name": "yeti-trix",
+      "email": "spencer.current@gmail.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yeti-Trix/sylo-plc-comms.git"
+  }
 }

package/scripts/cip_plc_info.py

@@ -1,57 +1,57 @@
-#!/usr/bin/env python3
-"""Full PLC controller attributes via ciplogix (read-only CIP Identity + attrs).
-
-Richer than plc_status.py (which is the pre-download keyswitch check). This is
-the agent-facing "tell me about this controller" tool.
-
-Usage:
-  py -3.12 cip_plc_info.py --ip 10.1.200.45
-"""
-
-from __future__ import annotations
-
-import argparse
-
-from _cip_client import ensure_ciplogix, open_driver, plc_info_dict
-from _download_allowlist import load_allowlist
-from _json_out import emit
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Full PLC controller info via ciplogix")
-    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
-    args = parser.parse_args()
-
-    try:
-        ensure_ciplogix()
-    except Exception as exc:
-        from _json_out import emit_error
-        emit_error(f"ciplogix setup failed: {exc}")
-
-    plc = open_driver(args.ip, init_tags=False)
-    try:
-        info = plc_info_dict(plc)
-        info["ip"] = args.ip
-        info["reachable"] = True
-        info["error"] = None
-    except Exception as exc:
-        plc.close()
-        from _json_out import emit_error
-        emit_error(f"get_plc_info failed: {exc}")
-        return
-    finally:
-        try:
-            plc.close()
-        except Exception:
-            pass
-
-    allowlist = load_allowlist()
-    info["in_allowlist"] = any(
-        isinstance(e, dict) and e.get("ip") == args.ip and e.get("enabled", True)
-        for e in allowlist.get("ips", [])
-    )
-    emit({"ok": True, **info})
-
-
-if __name__ == "__main__":
+#!/usr/bin/env python3
+"""Full PLC controller attributes via ciplogix (read-only CIP Identity + attrs).
+
+Richer than plc_status.py (which is the pre-download keyswitch check). This is
+the agent-facing "tell me about this controller" tool.
+
+Usage:
+  py -3.12 cip_plc_info.py --ip 10.1.200.45
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from _cip_client import ensure_ciplogix, open_driver, plc_info_dict
+from _download_allowlist import load_allowlist
+from _json_out import emit
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Full PLC controller info via ciplogix")
+    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
+    args = parser.parse_args()
+
+    try:
+        ensure_ciplogix()
+    except Exception as exc:
+        from _json_out import emit_error
+        emit_error(f"ciplogix setup failed: {exc}")
+
+    plc = open_driver(args.ip, init_tags=False)
+    try:
+        info = plc_info_dict(plc)
+        info["ip"] = args.ip
+        info["reachable"] = True
+        info["error"] = None
+    except Exception as exc:
+        plc.close()
+        from _json_out import emit_error
+        emit_error(f"get_plc_info failed: {exc}")
+        return
+    finally:
+        try:
+            plc.close()
+        except Exception:
+            pass
+
+    allowlist = load_allowlist()
+    info["in_allowlist"] = any(
+        isinstance(e, dict) and e.get("ip") == args.ip and e.get("enabled", True)
+        for e in allowlist.get("ips", [])
+    )
+    emit({"ok": True, **info})
+
+
+if __name__ == "__main__":
     main()

package/scripts/cip_tag_list.py

@@ -1,99 +1,99 @@
-#!/usr/bin/env python3
-"""List controller (and program) tags from a Logix PLC via ciplogix.
-
-Read-only. init_tags=True pulls the full tag list including UDT/struct layout;
-this is the same call ciplogix makes on connect when init_tags=True, just
-exposed explicitly. Optionally filter by substring and/or include program tags.
-
-Usage:
-  py -3.12 cip_tag_list.py --ip 10.1.200.45
-  py -3.12 cip_tag_list.py --ip 10.1.200.45 --filter IA00 --include-programs
-"""
-
-from __future__ import annotations
-
-import argparse
-
-from _cip_client import ensure_ciplogix, normalize_tag_entry, open_driver
-from _json_out import emit, emit_error
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="List Logix controller tags via ciplogix")
-    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
-    parser.add_argument("--filter", default="", help="Optional case-insensitive tag-name substring filter")
-    parser.add_argument(
-        "--include-programs",
-        action="store_true",
-        help="Also list program-scoped tags (one extra round trip per program)",
-    )
-    parser.add_argument(
-        "--limit",
-        type=int,
-        default=0,
-        help="Cap number of tags returned (0 = no cap). Apply after filtering.",
-    )
-    args = parser.parse_args()
-
-    try:
-        ensure_ciplogix()
-    except Exception as exc:
-        emit_error(f"ciplogix setup failed: {exc}")
-
-    plc = open_driver(args.ip, init_tags=True)
-    try:
-        flt = (args.filter or "").strip().lower()
-        try:
-            raw_tags = plc.get_tag_list()
-        except Exception as exc:
-            emit_error(f"get_tag_list failed: {exc}")
-            return
-
-        tags = [normalize_tag_entry(t) for t in raw_tags]
-
-        program_tags: list[dict] = []
-        if args.include_programs:
-            try:
-                programs = plc.get_programs()  # type: ignore[attr-defined]
-            except Exception:
-                programs = []
-            for prog in programs:
-                prog_name = prog if isinstance(prog, str) else getattr(prog, "name", str(prog))
-                try:
-                    p_raw = plc.get_tag_list(program=prog_name)
-                except Exception:
-                    p_raw = []
-                for t in p_raw:
-                    t["program"] = prog_name
-                    program_tags.append(normalize_tag_entry(t))
-
-        all_tags = tags + program_tags
-        if flt:
-            all_tags = [
-                t for t in all_tags
-                if flt in (str(t.get("tag_name") or "").lower())
-                or flt in (str(t.get("program") or "").lower())
-            ]
-        total = len(all_tags)
-        if args.limit and args.limit > 0:
-            all_tags = all_tags[: args.limit]
-
-        emit({
-            "ok": True,
-            "ip": args.ip,
-            "controller_tag_count": len(tags),
-            "program_tag_count": len(program_tags),
-            "total_matching": total,
-            "returned": len(all_tags),
-            "truncated": total > len(all_tags),
-            "tags": all_tags,
-        })
-    finally:
-        try:
-            plc.close()
-        except Exception:
-            pass
-
-
-if __name__ == "__main__":
+#!/usr/bin/env python3
+"""List controller (and program) tags from a Logix PLC via ciplogix.
+
+Read-only. init_tags=True pulls the full tag list including UDT/struct layout;
+this is the same call ciplogix makes on connect when init_tags=True, just
+exposed explicitly. Optionally filter by substring and/or include program tags.
+
+Usage:
+  py -3.12 cip_tag_list.py --ip 10.1.200.45
+  py -3.12 cip_tag_list.py --ip 10.1.200.45 --filter IA00 --include-programs
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from _cip_client import ensure_ciplogix, normalize_tag_entry, open_driver
+from _json_out import emit, emit_error
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="List Logix controller tags via ciplogix")
+    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
+    parser.add_argument("--filter", default="", help="Optional case-insensitive tag-name substring filter")
+    parser.add_argument(
+        "--include-programs",
+        action="store_true",
+        help="Also list program-scoped tags (one extra round trip per program)",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=0,
+        help="Cap number of tags returned (0 = no cap). Apply after filtering.",
+    )
+    args = parser.parse_args()
+
+    try:
+        ensure_ciplogix()
+    except Exception as exc:
+        emit_error(f"ciplogix setup failed: {exc}")
+
+    plc = open_driver(args.ip, init_tags=True)
+    try:
+        flt = (args.filter or "").strip().lower()
+        try:
+            raw_tags = plc.get_tag_list()
+        except Exception as exc:
+            emit_error(f"get_tag_list failed: {exc}")
+            return
+
+        tags = [normalize_tag_entry(t) for t in raw_tags]
+
+        program_tags: list[dict] = []
+        if args.include_programs:
+            try:
+                programs = plc.get_programs()  # type: ignore[attr-defined]
+            except Exception:
+                programs = []
+            for prog in programs:
+                prog_name = prog if isinstance(prog, str) else getattr(prog, "name", str(prog))
+                try:
+                    p_raw = plc.get_tag_list(program=prog_name)
+                except Exception:
+                    p_raw = []
+                for t in p_raw:
+                    t["program"] = prog_name
+                    program_tags.append(normalize_tag_entry(t))
+
+        all_tags = tags + program_tags
+        if flt:
+            all_tags = [
+                t for t in all_tags
+                if flt in (str(t.get("tag_name") or "").lower())
+                or flt in (str(t.get("program") or "").lower())
+            ]
+        total = len(all_tags)
+        if args.limit and args.limit > 0:
+            all_tags = all_tags[: args.limit]
+
+        emit({
+            "ok": True,
+            "ip": args.ip,
+            "controller_tag_count": len(tags),
+            "program_tag_count": len(program_tags),
+            "total_matching": total,
+            "returned": len(all_tags),
+            "truncated": total > len(all_tags),
+            "tags": all_tags,
+        })
+    finally:
+        try:
+            plc.close()
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
     main()

package/scripts/cip_tag_read.py

@@ -1,130 +1,130 @@
-#!/usr/bin/env python3
-"""Read one or many Logix tags from a PLC via ciplogix (read-only).
-
-Accepts a JSON list of tag names on stdin (--tags-json also accepted). Uses
-ciplogix multi-service read when more than one tag is given. Returns per-tag
-value + error. Bit/array element syntax follows pycomm3 conventions:
-  MyTag, MyTag.0, MyArray[3], MyStruct.Member, Program:MainProgram.MyTag
-
-Usage:
-  py -3.12 cip_tag_read.py --ip 10.1.200.45 --tags "MyDint,MyBool.0"
-  echo '["MyDint","MyReal"]' | py -3.12 cip_tag_read.py --ip 10.1.200.45 --stdin
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-
-from _cip_client import ensure_ciplogix, open_driver
-from _json_out import emit, emit_error
-
-
-def _coerce_value(v):
-    """Make ciplogix tag values JSON-serializable (bytes, structs, datetimes)."""
-    if v is None:
-        return None
-    if isinstance(v, (str, int, float, bool)):
-        return v
-    if isinstance(v, bytes):
-        try:
-            return v.decode("utf-8", errors="replace")
-        except Exception:
-            return list(v)
-    if isinstance(v, (list, tuple)):
-        return [_coerce_value(x) for x in v]
-    if isinstance(v, dict):
-        return {str(k): _coerce_value(val) for k, val in v.items()}
-    # pycomm3 struct Tag objects / datetime / enum -> string-ish
-    return str(v)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Read Logix tags via ciplogix")
-    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
-    parser.add_argument("--tags", default="", help="Comma-separated tag names")
-    parser.add_argument("--tags-json", default="", help="JSON array of tag names")
-    parser.add_argument("--stdin", action="store_true", help="Read JSON array of tags from stdin")
-    args = parser.parse_args()
-
-    # Resolve tag list
-    names: list[str] = []
-    if args.stdin:
-        raw = sys.stdin.read().strip()
-        try:
-            parsed = json.loads(raw) if raw else []
-        except json.JSONDecodeError as exc:
-            emit_error(f"stdin is not valid JSON: {exc}")
-            return
-        if not isinstance(parsed, list):
-            emit_error("stdin JSON must be an array of tag name strings.")
-            return
-        names = [str(x).strip() for x in parsed if str(x).strip()]
-    if args.tags_json:
-        try:
-            parsed = json.loads(args.tags_json)
-        except json.JSONDecodeError as exc:
-            emit_error(f"--tags-json is not valid JSON: {exc}")
-            return
-        names.extend(str(x).strip() for x in parsed if str(x).strip())
-    if args.tags:
-        names.extend(x.strip() for x in args.tags.split(",") if x.strip())
-
-    names = [n for n in names if n]
-    if not names:
-        emit_error("No tag names supplied. Use --tags, --tags-json, or --stdin.")
-
-    try:
-        ensure_ciplogix()
-    except Exception as exc:
-        emit_error(f"ciplogix setup failed: {exc}")
-
-    plc = open_driver(args.ip, init_tags=True)
-    try:
-        results: list[dict] = []
-        try:
-            resp = plc.read(*names)
-        except Exception as exc:
-            # All-failed path — still emit one error row per tag so the caller
-            # can see which tags were attempted.
-            for n in names:
-                results.append({"tag": n, "ok": False, "value": None, "error": str(exc)})
-            emit({"ok": True, "ip": args.ip, "results": results, "all_failed": True})
-            return
-
-        # plc.read returns a single Tag when one name, or a list of Tags when many.
-        resp_list = resp if isinstance(resp, list) else [resp]
-        for name, tag in zip(names, resp_list):
-            err = None
-            try:
-                err = getattr(tag, "error", None)
-                if not err and getattr(tag, "status", None) not in (None, "", "Success"):
-                    err = str(getattr(tag, "status"))
-            except Exception:
-                pass
-            results.append({
-                "tag": name,
-                "ok": not err,
-                "value": _coerce_value(getattr(tag, "value", None)),
-                "error": err,
-                "type": getattr(tag, "tag_type", None) or getattr(tag, "data_type_name", None),
-            })
-        ok_count = sum(1 for r in results if r["ok"])
-        emit({
-            "ok": True,
-            "ip": args.ip,
-            "requested": len(names),
-            "succeeded": ok_count,
-            "failed": len(names) - ok_count,
-            "results": results,
-        })
-    finally:
-        try:
-            plc.close()
-        except Exception:
-            pass
-
-
-if __name__ == "__main__":
+#!/usr/bin/env python3
+"""Read one or many Logix tags from a PLC via ciplogix (read-only).
+
+Accepts a JSON list of tag names on stdin (--tags-json also accepted). Uses
+ciplogix multi-service read when more than one tag is given. Returns per-tag
+value + error. Bit/array element syntax follows pycomm3 conventions:
+  MyTag, MyTag.0, MyArray[3], MyStruct.Member, Program:MainProgram.MyTag
+
+Usage:
+  py -3.12 cip_tag_read.py --ip 10.1.200.45 --tags "MyDint,MyBool.0"
+  echo '["MyDint","MyReal"]' | py -3.12 cip_tag_read.py --ip 10.1.200.45 --stdin
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from _cip_client import ensure_ciplogix, open_driver
+from _json_out import emit, emit_error
+
+
+def _coerce_value(v):
+    """Make ciplogix tag values JSON-serializable (bytes, structs, datetimes)."""
+    if v is None:
+        return None
+    if isinstance(v, (str, int, float, bool)):
+        return v
+    if isinstance(v, bytes):
+        try:
+            return v.decode("utf-8", errors="replace")
+        except Exception:
+            return list(v)
+    if isinstance(v, (list, tuple)):
+        return [_coerce_value(x) for x in v]
+    if isinstance(v, dict):
+        return {str(k): _coerce_value(val) for k, val in v.items()}
+    # pycomm3 struct Tag objects / datetime / enum -> string-ish
+    return str(v)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Read Logix tags via ciplogix")
+    parser.add_argument("--ip", required=True, help="Controller IPv4 address")
+    parser.add_argument("--tags", default="", help="Comma-separated tag names")
+    parser.add_argument("--tags-json", default="", help="JSON array of tag names")
+    parser.add_argument("--stdin", action="store_true", help="Read JSON array of tags from stdin")
+    args = parser.parse_args()
+
+    # Resolve tag list
+    names: list[str] = []
+    if args.stdin:
+        raw = sys.stdin.read().strip()
+        try:
+            parsed = json.loads(raw) if raw else []
+        except json.JSONDecodeError as exc:
+            emit_error(f"stdin is not valid JSON: {exc}")
+            return
+        if not isinstance(parsed, list):
+            emit_error("stdin JSON must be an array of tag name strings.")
+            return
+        names = [str(x).strip() for x in parsed if str(x).strip()]
+    if args.tags_json:
+        try:
+            parsed = json.loads(args.tags_json)
+        except json.JSONDecodeError as exc:
+            emit_error(f"--tags-json is not valid JSON: {exc}")
+            return
+        names.extend(str(x).strip() for x in parsed if str(x).strip())
+    if args.tags:
+        names.extend(x.strip() for x in args.tags.split(",") if x.strip())
+
+    names = [n for n in names if n]
+    if not names:
+        emit_error("No tag names supplied. Use --tags, --tags-json, or --stdin.")
+
+    try:
+        ensure_ciplogix()
+    except Exception as exc:
+        emit_error(f"ciplogix setup failed: {exc}")
+
+    plc = open_driver(args.ip, init_tags=True)
+    try:
+        results: list[dict] = []
+        try:
+            resp = plc.read(*names)
+        except Exception as exc:
+            # All-failed path — still emit one error row per tag so the caller
+            # can see which tags were attempted.
+            for n in names:
+                results.append({"tag": n, "ok": False, "value": None, "error": str(exc)})
+            emit({"ok": True, "ip": args.ip, "results": results, "all_failed": True})
+            return
+
+        # plc.read returns a single Tag when one name, or a list of Tags when many.
+        resp_list = resp if isinstance(resp, list) else [resp]
+        for name, tag in zip(names, resp_list):
+            err = None
+            try:
+                err = getattr(tag, "error", None)
+                if not err and getattr(tag, "status", None) not in (None, "", "Success"):
+                    err = str(getattr(tag, "status"))
+            except Exception:
+                pass
+            results.append({
+                "tag": name,
+                "ok": not err,
+                "value": _coerce_value(getattr(tag, "value", None)),
+                "error": err,
+                "type": getattr(tag, "tag_type", None) or getattr(tag, "data_type_name", None),
+            })
+        ok_count = sum(1 for r in results if r["ok"])
+        emit({
+            "ok": True,
+            "ip": args.ip,
+            "requested": len(names),
+            "succeeded": ok_count,
+            "failed": len(names) - ok_count,
+            "results": results,
+        })
+    finally:
+        try:
+            plc.close()
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
     main()