@synefex/node-red-sila2 0.1.0

package/src/get-property/sila-get-property.js

@@ -0,0 +1,114 @@
+"use strict";
+
+module.exports = function (RED) {
+  function SilaGetPropertyNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.connection = RED.nodes.getNode(config.connection);
+    node.feature = config.feature || "";
+    node.featureType = config.featureType || "str";
+    node.property = config.property || "";
+    node.propertyType = config.propertyType || "str";
+    node.outputProperty = config.outputProperty || "payload";
+    node.outputPropertyType = config.outputPropertyType || "msg";
+    node.unwrapSingle = config.unwrapSingle !== false; // default true
+
+    if (!node.connection) {
+      node.status({ fill: "red", shape: "ring", text: "no connection" });
+      return;
+    }
+
+    function applyConnStatus(status) {
+      switch (status.state) {
+        case "ok":
+          node.status({ fill: "green", shape: "dot", text: status.detail || "ok" });
+          break;
+        case "ready":
+          node.status({ fill: "grey", shape: "ring", text: "ready" });
+          break;
+        case "error":
+          node.status({ fill: "red", shape: "ring", text: status.detail || "error" });
+          break;
+        default:
+          node.status({ fill: "grey", shape: "ring", text: status.state || "" });
+      }
+    }
+    const unsub = node.connection.onStatus(applyConnStatus);
+
+    node.on("input", async (msg, send, done) => {
+      let feature, property;
+      try {
+        feature = RED.util.evaluateNodeProperty(node.feature, node.featureType, node, msg);
+        property = RED.util.evaluateNodeProperty(node.property, node.propertyType, node, msg);
+      } catch (err) {
+        if (done) done(err); else node.error(err, msg);
+        return;
+      }
+
+      if (typeof feature !== "string" || !feature) {
+        const err = new Error("SiLA get: feature name is missing");
+        if (done) done(err); else node.error(err, msg);
+        return;
+      }
+      if (typeof property !== "string" || !property) {
+        const err = new Error("SiLA get: property name is missing");
+        if (done) done(err); else node.error(err, msg);
+        return;
+      }
+
+      // SiLA convention: property getter is `Get_<PropertyName>`. If the
+      // user already prefixed Get_, use it verbatim.
+      const methodName = property.startsWith("Get_") ? property : `Get_${property}`;
+
+      let resp;
+      try {
+        resp = await node.connection.callUnary(feature, methodName, {});
+      } catch (err) {
+        node.status({ fill: "red", shape: "ring", text: "get failed" });
+        if (done) done(err); else node.error(err, msg);
+        return;
+      }
+
+      // Typical case: _Responses has a single field holding the property
+      // value. After SiLA-unwrap that single field IS the value. Surface
+      // it directly so `payload` is the value, not a wrapper. Keep the
+      // wrapper for multi-field responses (rare, but FDL allows it).
+      let payload = resp;
+      if (
+        node.unwrapSingle &&
+        resp &&
+        typeof resp === "object" &&
+        !Array.isArray(resp)
+      ) {
+        const keys = Object.keys(resp);
+        if (keys.length === 1) payload = resp[keys[0]];
+      }
+
+      try {
+        if (node.outputPropertyType === "msg") {
+          RED.util.setMessageProperty(msg, node.outputProperty, payload, true);
+        } else if (
+          node.outputPropertyType === "flow" ||
+          node.outputPropertyType === "global"
+        ) {
+          node.context()[node.outputPropertyType].set(node.outputProperty, payload);
+        } else {
+          RED.util.setMessageProperty(msg, node.outputProperty, payload, true);
+        }
+      } catch (err) {
+        if (done) done(err); else node.error(err, msg);
+        return;
+      }
+
+      send(msg);
+      if (done) done();
+    });
+
+    node.on("close", () => {
+      try { unsub(); } catch (_) { /* ignore */ }
+    });
+  }
+
+  RED.nodes.registerType("sila-get-property", SilaGetPropertyNode);
+};

package/src/lib/client.js

@@ -0,0 +1,216 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const grpc = require("@grpc/grpc-js");
+const protoLoader = require("@grpc/proto-loader");
+const { unwrap } = require("./unwrap");
+
+// Bundled protos: framework wrapper types + SiLAService (mandatory on every
+// SiLA server) + a sample domain feature (Mettler Toledo AX205 balance) for
+// out-of-the-box demos.
+const BUNDLED_PROTOS_DIR = path.join(__dirname, "..", "..", "protos");
+
+function listProtoFiles(dir) {
+  if (!dir || !fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((n) => n.endsWith(".proto"))
+    .map((n) => path.join(dir, n));
+}
+
+/**
+ * Load proto files via @grpc/proto-loader, then turn them into a grpc
+ * package object via grpc.loadPackageDefinition. The result is a nested
+ * namespace whose leaves are either Service constructors (callable as
+ * `new Cls(target, creds)`) or message-type definitions.
+ *
+ * `keepCase: true` keeps SiLA's PascalCase field names verbatim. Without
+ * it, proto-loader lowercases the first letter — would break callers that
+ * expect e.g. `WeightValue` instead of `weightValue`.
+ */
+function loadProtos({ extraProtoDirs = [], extraProtoFiles = [] } = {}) {
+  const includeDirs = [BUNDLED_PROTOS_DIR, ...extraProtoDirs.filter(Boolean)];
+  const files = [
+    ...listProtoFiles(BUNDLED_PROTOS_DIR),
+    ...extraProtoDirs.flatMap(listProtoFiles),
+    ...extraProtoFiles.filter(Boolean),
+  ];
+  if (files.length === 0) {
+    throw new Error("SiLA: no .proto files found (check extraProtoDirs config)");
+  }
+  const packageDef = protoLoader.loadSync(files, {
+    includeDirs,
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+  });
+  return grpc.loadPackageDefinition(packageDef);
+}
+
+/**
+ * Walk the loaded grpc package recursively. Build:
+ *  - byFull:  map of dotted fully-qualified service name → ServiceClass
+ *  - byShort: map of lowercase short name (last segment) → [{fq, ServiceClass}]
+ * Short-name collisions surface as a clear ambiguity error at lookup time.
+ */
+function indexServices(grpcPkg) {
+  const byShort = new Map();
+  const byFull = new Map();
+
+  function visit(node, prefix) {
+    if (!node || typeof node !== "object") return;
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      const fq = prefix ? `${prefix}.${key}` : key;
+      // grpc-js Service classes are functions decorated with .service +
+      // .serviceName by loadPackageDefinition. Message types are plain
+      // objects with codec methods — we don't index those.
+      if (typeof child === "function" && child.service && child.serviceName) {
+        byFull.set(fq, child);
+        const shortKey = key.toLowerCase();
+        const list = byShort.get(shortKey) || [];
+        list.push({ fq, ServiceClass: child, shortName: key });
+        byShort.set(shortKey, list);
+      } else if (child && typeof child === "object") {
+        visit(child, fq);
+      }
+    }
+  }
+  visit(grpcPkg, "");
+  return { byShort, byFull };
+}
+
+/**
+ * Build a SiLA client wrapper. Owns one grpc client instance per service
+ * (lazy), reusing the underlying channel via the same address+credentials.
+ */
+function createSilaClient({
+  target,
+  credentials,
+  extraProtoDirs = [],
+  extraProtoFiles = [],
+}) {
+  const grpcPkg = loadProtos({ extraProtoDirs, extraProtoFiles });
+  const { byShort, byFull } = indexServices(grpcPkg);
+  const clientByService = new Map(); // fq → grpc client instance
+
+  function resolveService(featureName) {
+    if (!featureName) throw new Error("SiLA: feature name is required");
+    if (featureName.includes(".") && byFull.has(featureName)) {
+      return { fq: featureName, ServiceClass: byFull.get(featureName) };
+    }
+    const entries = byShort.get(featureName.toLowerCase()) || [];
+    if (entries.length === 0) {
+      const known = [...byFull.keys()].join(", ") || "(none)";
+      throw new Error(
+        `SiLA: feature "${featureName}" not found. Loaded services: ${known}`,
+      );
+    }
+    if (entries.length > 1) {
+      throw new Error(
+        `SiLA: short name "${featureName}" is ambiguous: ` +
+          entries.map((e) => e.fq).join(", "),
+      );
+    }
+    return { fq: entries[0].fq, ServiceClass: entries[0].ServiceClass };
+  }
+
+  function getClient(fq, ServiceClass) {
+    let c = clientByService.get(fq);
+    if (!c) {
+      c = new ServiceClass(target, credentials);
+      clientByService.set(fq, c);
+    }
+    return c;
+  }
+
+  /**
+   * Call an unobservable command (or property getter — same wire mechanism).
+   *
+   * @param {string} featureName  short name (case-insensitive, e.g.
+   *                              "MettlerToledoAX205Controller") OR fully
+   *                              qualified (e.g.
+   *                              "sila2.master.thesis.weighing.mettlertoledoax205controller.v1.MettlerToledoAX205Controller")
+   * @param {string} methodName   verbatim method on the service
+   * @param {object} params       fields keyed by name as in the .proto
+   * @param {grpc.Metadata} [metadata]
+   * @returns {Promise<object>}   decoded + SiLA-unwrapped response
+   */
+  async function callUnary(featureName, methodName, params, metadata) {
+    const { fq, ServiceClass } = resolveService(featureName);
+    const client = getClient(fq, ServiceClass);
+    if (typeof client[methodName] !== "function") {
+      // Methods come from the .service descriptor; list them for the error.
+      const methods = Object.keys(ServiceClass.service || {});
+      throw new Error(
+        `SiLA: method "${methodName}" not found on feature "${featureName}". ` +
+          `Available: ${methods.join(", ")}`,
+      );
+    }
+
+    const resp = await new Promise((resolve, reject) => {
+      const cb = (err, value) => (err ? reject(err) : resolve(value));
+      if (metadata) client[methodName](params || {}, metadata, cb);
+      else client[methodName](params || {}, cb);
+    });
+    return unwrap(resp);
+  }
+
+  /**
+   * List loaded services (the union of bundled protos + any extras the
+   * connection was configured with). Returns fully-qualified names.
+   */
+  function listServices() {
+    return [...byFull.keys()];
+  }
+
+  /**
+   * Editor picker support: list every loaded service with its short name,
+   * fully-qualified name, and methods classified as "command" vs
+   * "property" by the SiLA naming convention (`Get_<X>` → property
+   * getter for property `<X>`; everything else → command).
+   *
+   * The classification is name-only — we don't inspect request-message
+   * fields. SiLA convention is strict enough that this is reliable for
+   * standard features; vendor-defined commands that happen to start
+   * with `Get_` and take no parameters would be misclassified, but
+   * that's a SiLA naming antipattern.
+   */
+  function listFeaturesForPicker() {
+    const features = [];
+    for (const [fq, ServiceClass] of byFull) {
+      const shortName = fq.split(".").pop();
+      const svcDesc = ServiceClass.service || {};
+      const methods = Object.keys(svcDesc)
+        .map((name) => {
+          if (name.startsWith("Get_")) {
+            return { name, kind: "property", propertyName: name.slice(4) };
+          }
+          return { name, kind: "command" };
+        })
+        .sort((a, b) => {
+          // Sort by display name (propertyName for properties, name for commands)
+          const an = a.kind === "property" ? a.propertyName : a.name;
+          const bn = b.kind === "property" ? b.propertyName : b.name;
+          return an.localeCompare(bn);
+        });
+      features.push({ shortName, fqName: fq, methods });
+    }
+    features.sort((a, b) => a.shortName.localeCompare(b.shortName));
+    return { features };
+  }
+
+  function close() {
+    for (const c of clientByService.values()) {
+      try { c.close(); } catch (_) { /* ignore */ }
+    }
+    clientByService.clear();
+  }
+
+  return { callUnary, listServices, listFeaturesForPicker, close };
+}
+
+module.exports = { createSilaClient, BUNDLED_PROTOS_DIR };

package/src/lib/picker/picker.js

@@ -0,0 +1,174 @@
+// Browser-side SiLA picker widget. Loaded once via the sila-connection
+// editor HTML; exposes window.SilaPicker.attach({ ... }) for action nodes.
+//
+// Two modes (set via opts.kind):
+//   "command"  — pick a SiLA command (for sila-call-command)
+//   "property" — pick a SiLA property (for sila-get-property)
+//
+// Cascade: connection -> feature -> command/property leaf
+//
+// Backed by GET /sila/conn/:id/features which returns the introspected
+// list of loaded features and their methods classified by name pattern.
+(function () {
+  if (window.SilaPicker) return; // idempotent
+
+  const $ = window.jQuery || window.$;
+
+  // jQuery rather than fetch so the editor's adminAuth bearer token is
+  // attached automatically by Node-RED's beforeSend hook.
+  function fetchJSON(url) {
+    return new Promise((resolve, reject) => {
+      $.ajax({ url: url, dataType: "json", method: "GET" })
+        .done(resolve)
+        .fail(function (xhr) {
+          let body = {};
+          try { body = JSON.parse(xhr.responseText || "{}"); } catch (_) { /* ignore */ }
+          const err = new Error(body.error || ("HTTP " + xhr.status));
+          err.status = xhr.status;
+          err.body = body;
+          reject(err);
+        });
+    });
+  }
+
+  function fillSelect($sel, items, opts) {
+    const { valueKey, labelFn, placeholder } = opts;
+    $sel.empty();
+    if (placeholder) {
+      $sel.append($("<option>").val("").text(placeholder));
+    }
+    for (const it of items || []) {
+      const v = valueKey ? it[valueKey] : "";
+      $sel.append($("<option>").val(v).text(labelFn(it)));
+    }
+  }
+
+  function attach(opts) {
+    const kind = opts.kind || "command"; // "command" | "property"
+    const $form = $(opts.formSelector || "form.dialog-form, .red-ui-editor-form");
+    const $conn = $("#" + (opts.connectionFieldId || "node-input-connection"));
+    const $feature = $("#" + (opts.featureFieldId || "node-input-feature"));
+    const $methodOut = $("#" + opts.methodFieldId);
+    const $container = $methodOut.closest(".form-row");
+
+    // Idempotent: rebuild on each attach call (Node-RED reuses the
+    // dialog DOM across edits of different nodes).
+    $form.find(".sila-picker-rows").remove();
+
+    const leafLabel = (kind === "command") ? "Command" : "Property";
+    const leafIcon = (kind === "command") ? "fa-bolt" : "fa-eye";
+
+    const $rows = $(`
+      <div class="sila-picker-rows" style="border:1px dashed #d8d8d8;padding:10px;margin-bottom:8px;border-radius:4px;background:#fafafa">
+        <div class="sila-pick-header" style="font-size:11px;color:#888;margin-bottom:6px;">
+          <i class="fa fa-sitemap"></i> Browse loaded features (or type below for manual entry)
+        </div>
+        <div class="sila-pick-info" style="display:none;padding:8px;font-size:12px;border-radius:3px;margin-bottom:4px;"></div>
+        <div class="form-row" style="margin-bottom:6px">
+          <label><i class="fa fa-cube"></i> Feature</label>
+          <select class="sila-pick-feature" style="width:70%"></select>
+        </div>
+        <div class="form-row" style="margin-bottom:6px">
+          <label><i class="fa ${leafIcon}"></i> ${leafLabel}</label>
+          <select class="sila-pick-method" style="width:70%"></select>
+        </div>
+      </div>
+    `);
+    $container.before($rows);
+
+    const $featureSel = $rows.find(".sila-pick-feature");
+    const $methodSel = $rows.find(".sila-pick-method");
+    const $info = $rows.find(".sila-pick-info");
+
+    let cachedFeatures = [];
+
+    function showInfo(msg, color) {
+      $info.text(msg)
+        .css("background", color || "#fff3cd")
+        .css("color", color === "#f8d7da" ? "#721c24" : "#856404")
+        .show();
+    }
+    function clearInfo() { $info.hide(); }
+
+    async function loadFeatures() {
+      const connId = $conn.val();
+      if (!connId) {
+        showInfo("Pick a connection first.");
+        fillSelect($featureSel, [], { placeholder: "—" });
+        fillSelect($methodSel, [], { placeholder: "—" });
+        return;
+      }
+      try {
+        const data = await fetchJSON("sila/conn/" + encodeURIComponent(connId) + "/features");
+        cachedFeatures = data.features || [];
+        clearInfo();
+        // Show only features that have at least one method of our kind.
+        const visibleFeatures = cachedFeatures.filter(
+          (f) => f.methods.some((m) => m.kind === kind),
+        );
+        fillSelect($featureSel, visibleFeatures, {
+          valueKey: "shortName",
+          labelFn: (f) => f.shortName,
+          placeholder: visibleFeatures.length
+            ? "— pick a feature —"
+            : `(no features with ${kind}s loaded)`,
+        });
+        // Preselect from existing manual value if it matches a loaded feature.
+        const cur = $feature.val();
+        if (cur && visibleFeatures.some((f) => f.shortName === cur)) {
+          $featureSel.val(cur);
+        }
+        renderMethods();
+      } catch (err) {
+        if (err.status === 404) {
+          showInfo("Connection not deployed yet — deploy first to enable picker.");
+        } else {
+          showInfo("Picker error: " + err.message, "#f8d7da");
+        }
+      }
+    }
+
+    function renderMethods() {
+      const featName = $featureSel.val();
+      const feat = cachedFeatures.find((f) => f.shortName === featName);
+      if (!feat) {
+        fillSelect($methodSel, [], { placeholder: "—" });
+        return;
+      }
+      const filtered = feat.methods.filter((m) => m.kind === kind);
+      fillSelect($methodSel, filtered, {
+        valueKey: kind === "command" ? "name" : "propertyName",
+        labelFn: (m) => kind === "command" ? m.name : m.propertyName,
+        placeholder: filtered.length ? `— pick a ${kind} —` : `(no ${kind}s on this feature)`,
+      });
+      // Preselect from existing manual value if it matches.
+      const curMethod = $methodOut.val();
+      if (curMethod) {
+        const opt = filtered.find((m) =>
+          (kind === "command" ? m.name : m.propertyName) === curMethod,
+        );
+        if (opt) $methodSel.val(curMethod);
+      }
+    }
+
+    // Wire interactions:
+    //  - Feature change → write to manual feature field, refresh method list,
+    //    clear method (user must re-pick to avoid silently keeping a stale value).
+    //  - Method change → write to manual method field.
+    //  - Connection change → refresh everything from scratch.
+    $featureSel.on("change", function () {
+      const v = $featureSel.val();
+      $feature.val(v);
+      $methodOut.val("");
+      renderMethods();
+    });
+    $methodSel.on("change", function () {
+      $methodOut.val($methodSel.val());
+    });
+    $conn.on("change", loadFeatures);
+
+    loadFeatures();
+  }
+
+  window.SilaPicker = { attach };
+})();

package/src/lib/unwrap.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/**
+ * Unwrap SiLA basic-type wrappers from a decoded gRPC response object.
+ *
+ * Every SiLA basic type (String, Real, Integer, Boolean, ...) is encoded
+ * as a single-field protobuf message named `value`. Recursively peel
+ * those wrappers off so callers see native values:
+ *
+ *     { Status: { value: "S S" }, WeightValue: { value: 82.68 } }
+ *  →  { Status: "S S",            WeightValue: 82.68 }
+ *
+ * Lists pass through with element-wise unwrap. Structures (multi-field
+ * messages) are recursed into. Buffers are passed through verbatim
+ * (SiLA's Binary type may be raw bytes or a transfer UUID — handled at
+ * the call site, not here).
+ */
+function unwrap(obj) {
+  if (obj == null || typeof obj !== "object") return obj;
+  if (Buffer.isBuffer(obj) || obj instanceof Uint8Array) return obj;
+  if (Array.isArray(obj)) return obj.map(unwrap);
+
+  const keys = Object.keys(obj);
+  // Single-field wrapper named "value" → SiLA basic type. Unwrap.
+  if (keys.length === 1 && keys[0] === "value") {
+    return unwrap(obj.value);
+  }
+
+  // Otherwise it's a Structure (or _Responses message): recurse field-wise.
+  const out = {};
+  for (const k of keys) out[k] = unwrap(obj[k]);
+  return out;
+}
+
+module.exports = { unwrap };