node-red-contrib-i3x 0.0.2 → 0.0.4

package/.claude/settings.local.json

@@ -7,7 +7,8 @@
       "Bash(npm test:*)",
       "Bash(node-red:*)",
       "Bash(npx node-red:*)",
-      "Bash(docker compose:*)"
+      "Bash(docker compose:*)",
+      "Bash(ls /home/la/private/node-red-contrib-i3x/docker-compose* /home/la/private/node-red-contrib-i3x/Dockerfile* 2>/dev/null)"
     ]
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # Changelog
 
+## 0.0.4 (2026-04-12)
+
+Migration to i3X API 1.0-Beta specification with enhanced query capabilities and improved API alignment.
+
+### Added
+
+- **Server Info Endpoint** – New `getInfo()` method retrieves server metadata (spec version, server version, capabilities) from `GET /info` endpoint with TTL caching
+- **Single-Object History Query** – New `getHistory(elementId, options)` method for `GET /objects/{elementId}/history` endpoint
+- **Partial Response Handling** – History queries now detect HTTP 206 status and set `_partial: true` flag on results when server returns incomplete data
+- **Root Objects Filter** – `getObjects()` now supports `root: true` parameter to retrieve only root-level objects
+- **Enhanced Subscribe Options** – Subscribe node now supports `maxDepth`, `includeMetadata`, and `returnMode` parameters for fine-grained control
+
+### Changed
+
+- **API Version Update** – Updated from i3X v0.0.1 to 1.0-Beta specification
+- **API Documentation URL** – Changed from `https://i3x.cesmii.net/docs` to `https://api.i3x.dev/v1/docs`
+- **Parameter Naming** – `typeId` parameter renamed to `typeElementId` in `getObjects()` (legacy `typeId` still supported as alias)
+- **Relationship Type Parameter** – Fixed casing from `relationshiptype` to `relationshipType` in `getRelatedObjects()`
+- **History Query Implementation** – `getHistoryBulk()` now uses `_requestRaw()` to access HTTP status codes for partial response detection
+
+### Tests
+
+- Updated all test cases to reflect 1.0-Beta API changes
+- Added tests for new `getInfo()` endpoint
+- Added tests for single-object history query
+- Added tests for partial response handling (HTTP 206)
+- Updated integration tests for new parameter names
+
+## 0.0.3 (2026-03-10)
+
+Hardening, security improvements, and new browser widget features.
+
+### Added
+
+- **Live Values in Browser Widget** – The tree view now displays the current value, quality, and timestamp next to each element. Values are fetched automatically when expanding types or children, and on search results. Hover to see full value with quality and timestamp.
+- **Test Connection Button** – Server config panel now includes a "Test Connection" button to verify connectivity without deploying
+- **New admin endpoint** `POST /i3x-server/:id/browse/values` – Batch-reads live values for up to 50 elements (used by browser widget)
+- **`statusError()` utility** – Smarter error message truncation (48 chars with `...`) replacing the hard `substring(0, 32)` cut across all nodes
+- **`clampMaxDepth()` utility** – Validates and clamps `maxDepth` to 0–100 range, preventing negative or excessively large values
+
+### Security
+
+- **HTTPS warning** – Nodes now warn at startup when credentials are sent over plain HTTP to non-localhost servers
+- **Error response sanitization** – `_wrapError()` strips sensitive fields (`token`, `password`, `apiKey`, `secret`) from API error response bodies to prevent accidental credential leakage in logs
+
+### Fixed
+
+- **SSE auth header duplication** – `streamSubscription()` now copies all configured headers cleanly via spread instead of manually duplicating individual auth headers
+- **Poll interval minimum** – Increased from 500ms to 1000ms to prevent accidental API overload
+
+### Changed
+
+- Error status messages across all nodes now show up to 48 characters (was 32)
+- `maxDepth` is validated on all nodes that accept it (read, history, subscribe)
+
 ## 0.0.2 (2026-03-05)
 
 Compliance improvements based on [i3X Client Developer Guidelines](https://www.i3x.dev/sdk/category/client-developers).

package/README.md

@@ -4,7 +4,7 @@ Node-RED nodes for the **i3X** (Industrial Information Interoperability eXchange
 
 i3X is an open, vendor-agnostic REST API specification for standardised access to contextualised manufacturing information platforms (Historians, MES, MOM, etc.).
 
-> **Note:** The i3X API is currently in **pre-alpha (v0)**. Response structures may change as the specification evolves.
+> **Note:** The i3X API is currently in **beta (v1.0-Beta)**. Response structures may change as the specification evolves.
 
 ## Installation
 
@@ -108,10 +108,11 @@ The shared HTTP client (`lib/i3x-client.js`) implements all [i3X Client Develope
 
 ## API Endpoints Used
 
-This package targets the [i3X API Prototype v0.0.1](https://api.i3x.dev/v0/docs):
+This package targets the [i3X API 1.0-Beta](https://api.i3x.dev/v1/docs):
 
 | Category  | Method | Endpoint                                     |
 | --------- | ------ | -------------------------------------------- |
+| Info      | GET    | `/info`                                      |
 | Explore   | GET    | `/namespaces`                                |
 | Explore   | GET    | `/objecttypes`                               |
 | Explore   | POST   | `/objecttypes/query`                         |
@@ -121,6 +122,7 @@ This package targets the [i3X API Prototype v0.0.1](https://api.i3x.dev/v0/docs)
 | Explore   | POST   | `/objects/list`                              |
 | Explore   | POST   | `/objects/related`                           |
 | Query     | POST   | `/objects/value`                             |
+| Query     | GET    | `/objects/{elementId}/history`               |
 | Query     | POST   | `/objects/history`                           |
 | Update    | PUT    | `/objects/{elementId}/value`                 |
 | Update    | PUT    | `/objects/{elementId}/history`               |

package/lib/i3x-client.js

@@ -1,10 +1,10 @@
 /**
  * I3XClient – Shared HTTP client for the i3X (CESMII) API.
  *
- * Wraps all REST endpoints described in the i3X OpenAPI v0.0.1 spec.
+ * Wraps all REST endpoints described in the i3X OpenAPI 1.0-Beta spec.
  * Used by every node-red-contrib-i3x node via the i3x-server config node.
  *
- * @see https://i3x.cesmii.net/docs
+ * @see https://api.i3x.dev/v1/docs
  */
 "use strict";
 
@@ -84,6 +84,14 @@ class I3XClient extends EventEmitter {
         this.authType = config.authType || "none";
         this.timeout = config.timeout || 10000;
 
+        // Warn if credentials are sent over plain HTTP (not localhost)
+        if (this.authType !== "none" && this.baseUrl && !this.baseUrl.startsWith("https://")) {
+            const isLocal = /^https?:\/\/(localhost|127\.0\.0\.1|::1)(:|\/|$)/.test(this.baseUrl);
+            if (!isLocal) {
+                this._httpsWarning = "Credentials sent over plain HTTP – use HTTPS in production";
+            }
+        }
+
         const axiosConfig = {
             baseURL: this._prefix(),
             timeout: this.timeout,
@@ -110,6 +118,21 @@ class I3XClient extends EventEmitter {
         this._rateLimiter = new RateLimiter();
     }
 
+    // ── Server Info ──────────────────────────────────────────────────────
+
+    /**
+     * Retrieve server information (no authentication required).
+     * @returns {Promise<{specVersion:string, serverVersion:string, serverName:string, capabilities:object}>}
+     */
+    async getInfo() {
+        const cacheKey = "info";
+        const cached = this._cache.get(cacheKey);
+        if (cached) return cached;
+        const result = await this._get("/info");
+        this._cache.set(cacheKey, result);
+        return result;
+    }
+
     // ── Explore ────────────────────────────────────────────────────────
 
     /** @returns {Promise<Array<{uri:string, displayName:string}>>} */
@@ -158,14 +181,18 @@ class I3XClient extends EventEmitter {
     }
 
     /**
-     * @param {object} [options]
-     * @param {string}  [options.typeId]
+     * @param {object}  [options]
+     * @param {string}  [options.typeElementId] – filter by type (Beta spec name)
+     * @param {string}  [options.typeId]        – legacy alias for typeElementId
      * @param {boolean} [options.includeMetadata]
+     * @param {boolean} [options.root]          – return only root objects
      */
     async getObjects(options = {}) {
         const params = {};
-        if (options.typeId) params.typeId = options.typeId;
+        const typeFilter = options.typeElementId || options.typeId;
+        if (typeFilter) params.typeElementId = typeFilter;
         if (options.includeMetadata) params.includeMetadata = true;
+        if (options.root) params.root = true;
         return this._get("/objects", params);
     }
 
@@ -188,7 +215,7 @@ class I3XClient extends EventEmitter {
      */
     async getRelatedObjects(elementIds, options = {}) {
         const body = { elementIds };
-        if (options.relationshipType) body.relationshiptype = options.relationshipType;
+        if (options.relationshipType) body.relationshipType = options.relationshipType;
         if (options.includeMetadata) body.includeMetadata = true;
         return this._post("/objects/related", body);
     }
@@ -207,6 +234,7 @@ class I3XClient extends EventEmitter {
     }
 
     /**
+     * Bulk historical values query (POST).
      * @param {string[]} elementIds
      * @param {object}   [options]
      * @param {string}   [options.startTime] – ISO 8601
@@ -218,7 +246,37 @@ class I3XClient extends EventEmitter {
         if (options.startTime) body.startTime = options.startTime;
         if (options.endTime) body.endTime = options.endTime;
         if (options.maxDepth !== undefined) body.maxDepth = options.maxDepth;
-        return this._post("/objects/history", body);
+        const res = await this._requestRaw("post", "/objects/history", { data: body });
+        const result = I3XClient._unwrapEnvelope(res.data);
+        if (res.status === 206) {
+            result._partial = true;
+        }
+        return result;
+    }
+
+    /**
+     * Single-object historical values query (GET).
+     * @param {string} elementId
+     * @param {object} [options]
+     * @param {string} [options.startTime] – ISO 8601
+     * @param {string} [options.endTime]   – ISO 8601
+     * @param {number} [options.maxDepth]
+     */
+    async getHistory(elementId, options = {}) {
+        const params = {};
+        if (options.startTime) params.startTime = options.startTime;
+        if (options.endTime) params.endTime = options.endTime;
+        if (options.maxDepth !== undefined) params.maxDepth = options.maxDepth;
+        const res = await this._requestRaw(
+            "get",
+            `/objects/${encodeURIComponent(elementId)}/history`,
+            { params }
+        );
+        const result = I3XClient._unwrapEnvelope(res.data);
+        if (res.status === 206) {
+            result._partial = true;
+        }
+        return result;
     }
 
     // ── Update ─────────────────────────────────────────────────────────
@@ -259,82 +317,124 @@ class I3XClient extends EventEmitter {
         }
     }
 
-    // ── Subscribe ──────────────────────────────────────────────────────
-
-    async listSubscriptions() {
-        return this._get("/subscriptions");
-    }
+    // ── Subscribe (Beta-Spec: body-based endpoints) ──────────────────
 
-    /** @returns {Promise<{subscriptionId:string, message:string}>} */
-    async createSubscription() {
-        return this._post("/subscriptions", {});
+    /**
+     * Create a new subscription.
+     * @param {object} [options]
+     * @param {string} [options.clientId]     – optional client identifier
+     * @param {string} [options.displayName]  – optional human-readable name
+     * @returns {Promise<{subscriptionId:string, clientId?:string, displayName?:string}>}
+     */
+    async createSubscription(options = {}) {
+        const body = {};
+        if (options.clientId) body.clientId = options.clientId;
+        if (options.displayName) body.displayName = options.displayName;
+        return this._post("/subscriptions", body);
     }
 
-    /** @param {string} subscriptionId */
-    async getSubscription(subscriptionId) {
-        return this._get(`/subscriptions/${encodeURIComponent(subscriptionId)}`);
+    /**
+     * List subscriptions by IDs.
+     * @param {string[]} subscriptionIds
+     * @param {object}   [options]
+     * @param {string}   [options.clientId]
+     */
+    async listSubscriptions(subscriptionIds, options = {}) {
+        const body = { subscriptionIds };
+        if (options.clientId) body.clientId = options.clientId;
+        return this._post("/subscriptions/list", body);
     }
 
-    /** @param {string} subscriptionId */
-    async deleteSubscription(subscriptionId) {
-        return this._delete(`/subscriptions/${encodeURIComponent(subscriptionId)}`);
+    /**
+     * Delete one or more subscriptions.
+     * @param {string[]} subscriptionIds
+     * @param {object}   [options]
+     * @param {string}   [options.clientId]
+     */
+    async deleteSubscriptions(subscriptionIds, options = {}) {
+        const body = { subscriptionIds };
+        if (options.clientId) body.clientId = options.clientId;
+        return this._post("/subscriptions/delete", body);
     }
 
     /**
+     * Register monitored items on a subscription.
      * @param {string}   subscriptionId
      * @param {string[]} elementIds
-     * @param {number}   [maxDepth]
+     * @param {object}   [options]
+     * @param {number}   [options.maxDepth]  – default 1
+     * @param {string}   [options.clientId]
      */
-    async registerMonitoredItems(subscriptionId, elementIds, maxDepth = 1) {
-        const body = { elementIds, maxDepth };
-        return this._post(
-            `/subscriptions/${encodeURIComponent(subscriptionId)}/register`,
-            body
-        );
+    async registerMonitoredItems(subscriptionId, elementIds, options = {}) {
+        // Support legacy positional maxDepth: registerMonitoredItems(id, ids, 2)
+        if (typeof options === "number") {
+            options = { maxDepth: options };
+        }
+        const body = { subscriptionId, elementIds, maxDepth: options.maxDepth !== undefined ? options.maxDepth : 1 };
+        if (options.clientId) body.clientId = options.clientId;
+        return this._post("/subscriptions/register", body);
     }
 
     /**
+     * Unregister monitored items from a subscription.
      * @param {string}   subscriptionId
      * @param {string[]} elementIds
+     * @param {object}   [options]
+     * @param {string}   [options.clientId]
      */
-    async unregisterMonitoredItems(subscriptionId, elementIds) {
-        const body = { elementIds };
-        return this._post(
-            `/subscriptions/${encodeURIComponent(subscriptionId)}/unregister`,
-            body
-        );
+    async unregisterMonitoredItems(subscriptionId, elementIds, options = {}) {
+        const body = { subscriptionId, elementIds };
+        if (options.clientId) body.clientId = options.clientId;
+        return this._post("/subscriptions/unregister", body);
     }
 
     /**
-     * Open an SSE stream for the given subscription.
+     * Open an SSE stream for the given subscription (POST).
      * Supports automatic reconnection on stream errors.
      *
      * @param {string}   subscriptionId
      * @param {object}   callbacks
      * @param {function} callbacks.onData  – called with each parsed SSE event
-     * @param {function} [callbacks.onError] – called on stream errors (instead of EventEmitter)
+     * @param {function} [callbacks.onError] – called on stream errors
      * @param {function} [callbacks.onReconnect] – called when a reconnection attempt starts
-     * @param {number}   [maxReconnects=5] – max consecutive reconnection attempts
+     * @param {object}   [options]
+     * @param {string}   [options.clientId]
+     * @param {number}   [options.maxReconnects=5]
      * @returns {{ close: function }} handle to close the stream
      */
-    streamSubscription(subscriptionId, callbacks, maxReconnects = 5) {
+    streamSubscription(subscriptionId, callbacks, options = {}) {
         if (typeof callbacks === "function") {
             callbacks = { onData: callbacks };
         }
+        // Support legacy positional maxReconnects number
+        if (typeof options === "number") {
+            options = { maxReconnects: options };
+        }
         const { onData, onError, onReconnect } = callbacks;
+        const maxReconnects = options.maxReconnects !== undefined ? options.maxReconnects : 5;
+
+        const url = `${this._prefix()}/subscriptions/stream`;
+        const postBody = { subscriptionId };
+        if (options.clientId) postBody.clientId = options.clientId;
 
-        const url = `${this._prefix()}/subscriptions/${encodeURIComponent(subscriptionId)}/stream`;
         let controller = new AbortController();
         let closed = false;
         let reconnectCount = 0;
 
-        const headers = { ...this.http.defaults.headers.common, Accept: "text/event-stream" };
-        if (this.http.defaults.headers["Authorization"]) {
-            headers["Authorization"] = this.http.defaults.headers["Authorization"];
-        }
-        if (this.http.defaults.headers["X-API-Key"]) {
-            headers["X-API-Key"] = this.http.defaults.headers["X-API-Key"];
-        }
+        const headers = {
+            ...this.http.defaults.headers.common,
+            ...this.http.defaults.headers,
+            Accept: "text/event-stream",
+            "Content-Type": "application/json",
+        };
+        // Remove non-header axios defaults that got spread in
+        delete headers.common;
+        delete headers.get;
+        delete headers.post;
+        delete headers.put;
+        delete headers.delete;
+        delete headers.patch;
+        delete headers.head;
         if (this.http.defaults.auth) {
             const b64 = Buffer.from(
                 `${this.http.defaults.auth.username}:${this.http.defaults.auth.password}`
@@ -347,8 +447,9 @@ class I3XClient extends EventEmitter {
             try {
                 controller = new AbortController();
                 const response = await axios({
-                    method: "get",
+                    method: "post",
                     url,
+                    data: postBody,
                     headers,
                     responseType: "stream",
                     signal: controller.signal,
@@ -410,14 +511,19 @@ class I3XClient extends EventEmitter {
     }
 
     /**
-     * Poll-based sync: returns and clears queued updates.
+     * Poll-based sync: acknowledge previously received updates and return pending ones.
      * @param {string} subscriptionId
+     * @param {object} [options]
+     * @param {number} [options.lastSequenceNumber] – acknowledge events up to this sequence number
+     * @param {string} [options.clientId]
      */
-    async syncSubscription(subscriptionId) {
-        return this._post(
-            `/subscriptions/${encodeURIComponent(subscriptionId)}/sync`,
-            {}
-        );
+    async syncSubscription(subscriptionId, options = {}) {
+        const body = { subscriptionId };
+        if (options.lastSequenceNumber !== undefined) {
+            body.lastSequenceNumber = options.lastSequenceNumber;
+        }
+        if (options.clientId) body.clientId = options.clientId;
+        return this._post("/subscriptions/sync", body);
     }
 
     // ── Utility ────────────────────────────────────────────────────────
@@ -470,15 +576,38 @@ class I3XClient extends EventEmitter {
 
     /**
      * Central request dispatcher with retry logic, Retry-After support, and rate limiting.
+     * Returns unwrapped result data. Use _requestRaw for full response access.
      * @private
      */
     async _request(method, path, opts = {}) {
+        const res = await this._requestRaw(method, path, opts);
+        return I3XClient._unwrapEnvelope(res.data);
+    }
+
+    /**
+     * Unwrap the Beta-Spec response envelope if present.
+     * SuccessResponse: {success, result} → result
+     * BulkResponse:    {success, results} → results
+     * @private
+     */
+    static _unwrapEnvelope(data) {
+        if (data && typeof data === "object" && data.success === true) {
+            if ("result" in data) return data.result;
+            if ("results" in data) return data.results;
+        }
+        return data;
+    }
+
+    /**
+     * Central request dispatcher returning the full axios response.
+     * @private
+     */
+    async _requestRaw(method, path, opts = {}) {
         await this._rateLimiter.acquire();
         let lastErr;
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
-                const res = await this.http.request({ method, url: path, ...opts });
-                return res.data;
+                return await this.http.request({ method, url: path, ...opts });
             } catch (err) {
                 lastErr = err;
                 const status = err.response && err.response.status;
@@ -513,7 +642,17 @@ class I3XClient extends EventEmitter {
         if (err.response) {
             wrapped.statusCode = err.response.status;
             wrapped.statusText = err.response.statusText;
-            wrapped.body = err.response.data;
+            // Sanitize response body to avoid leaking auth details
+            const body = err.response.data;
+            if (body && typeof body === "object") {
+                const sanitized = { ...body };
+                for (const key of ["authorization", "token", "apiKey", "api_key", "password", "secret"]) {
+                    delete sanitized[key];
+                }
+                wrapped.body = sanitized;
+            } else {
+                wrapped.body = body;
+            }
         } else if (err.code) {
             wrapped.code = err.code;
         }

package/lib/node-utils.js

@@ -58,4 +58,30 @@ function safeSend(node, send) {
     return send || function () { node.send.apply(node, arguments); };
 }
 
-module.exports = { bindServer, parseIds, safeSend };
+/**
+ * Truncate an error message for node status display.
+ * Keeps up to 48 characters and appends "..." if truncated.
+ * @param {string} msg
+ * @returns {string}
+ */
+function statusError(msg) {
+    if (!msg) return "error";
+    if (msg.length <= 48) return msg;
+    return msg.substring(0, 45) + "...";
+}
+
+/**
+ * Clamp maxDepth to a valid range (0–100).
+ * @param {number} val
+ * @param {number} [fallback=1]
+ * @returns {number}
+ */
+function clampMaxDepth(val, fallback) {
+    if (fallback === undefined) fallback = 1;
+    var n = parseInt(val, 10);
+    if (isNaN(n) || n < 0) return fallback;
+    if (n > 100) return 100;
+    return n;
+}
+
+module.exports = { bindServer, parseIds, safeSend, statusError, clampMaxDepth };

package/nodes/i3x-browse.html

@@ -21,6 +21,9 @@
         <label for="node-input-elementId"><i class="fa fa-crosshairs"></i> Element ID</label>
         <input type="text" id="node-input-elementId" placeholder="optional – filter by element ID">
     </div>
+    <div class="form-row i3x-browse-elementId">
+        <div id="i3x-browse-browser"></div>
+    </div>
     <div class="form-row i3x-browse-typeId">
         <label for="node-input-typeId"><i class="fa fa-filter"></i> Type ID</label>
         <input type="text" id="node-input-typeId" placeholder="optional – filter objects by type">
@@ -66,6 +69,7 @@
     <h3>Details</h3>
     <p>This node talks to the <b>Explore</b> endpoints of the i3X API.
     <code>msg</code> properties override the values configured in the node editor.</p>
+    <p>Use the <b>Browse</b> button to visually select an element from the server.</p>
 </script>
 
 <script type="text/javascript">
@@ -101,6 +105,15 @@
             }
             target.on("change", toggle);
             toggle();
+
+            if (window.I3XBrowser) {
+                this._browser = I3XBrowser.create({
+                    container: "#i3x-browse-browser",
+                    serverField: "#node-input-server",
+                    targetField: "#node-input-elementId",
+                    mode: "single",
+                });
+            }
         },
     });
 </script>

package/nodes/i3x-browse.js

@@ -3,7 +3,7 @@
  */
 "use strict";
 
-const { bindServer, safeSend } = require("../lib/node-utils");
+const { bindServer, parseIds, safeSend, statusError } = require("../lib/node-utils");
 
 module.exports = function (RED) {
     function I3XBrowseNode(config) {
@@ -24,13 +24,13 @@ module.exports = function (RED) {
             const client = node.server.client;
 
             const target = msg.browseTarget || node.browseTarget;
-            const elementId = msg.elementId || node.elementId;
+            const ids = parseIds(msg.elementId || node.elementId);
             const typeId = msg.typeId || node.typeId;
             const nsUri = msg.namespaceUri || node.namespaceUri;
             const inclMeta = msg.includeMetadata !== undefined ? msg.includeMetadata : node.includeMetadata;
             const relType = msg.relationshipType || node.relationshipType;
 
-            node.status({ fill: "blue", shape: "dot", text: "requesting..." });
+            node.status({ fill: "blue", shape: "dot", text: "browsing " + target + "..." });
 
             try {
                 let result;
@@ -39,51 +39,46 @@ module.exports = function (RED) {
                         result = await client.getNamespaces();
                         break;
                     case "objecttypes":
-                        if (elementId) {
-                            const ids = Array.isArray(elementId) ? elementId : [elementId];
+                        if (ids.length) {
                             result = await client.queryObjectTypes(ids);
                         } else {
                             result = await client.getObjectTypes({ namespaceUri: nsUri || undefined });
                         }
                         break;
                     case "relationshiptypes":
-                        if (elementId) {
-                            const ids = Array.isArray(elementId) ? elementId : [elementId];
+                        if (ids.length) {
                             result = await client.queryRelationshipTypes(ids);
                         } else {
                             result = await client.getRelationshipTypes({ namespaceUri: nsUri || undefined });
                         }
                         break;
                     case "objects":
-                        if (elementId) {
-                            const ids = Array.isArray(elementId) ? elementId : [elementId];
+                        if (ids.length) {
                             result = await client.listObjects(ids, { includeMetadata: inclMeta });
                         } else {
                             result = await client.getObjects({ typeId: typeId || undefined, includeMetadata: inclMeta });
                         }
                         break;
                     case "related":
-                        if (!elementId) {
+                        if (!ids.length) {
                             throw new Error("elementId is required for related objects query");
                         }
-                        {
-                            const ids = Array.isArray(elementId) ? elementId : [elementId];
-                            result = await client.getRelatedObjects(ids, {
-                                relationshipType: relType || undefined,
-                                includeMetadata: inclMeta,
-                            });
-                        }
+                        result = await client.getRelatedObjects(ids, {
+                            relationshipType: relType || undefined,
+                            includeMetadata: inclMeta,
+                        });
                         break;
                     default:
                         throw new Error("Unknown browse target: " + target);
                 }
 
+                const count = Array.isArray(result) ? result.length : 1;
                 msg.payload = result;
-                node.status({ fill: "green", shape: "dot", text: "ok" });
+                node.status({ fill: "green", shape: "dot", text: count + " " + target });
                 send(msg);
                 if (done) done();
             } catch (err) {
-                node.status({ fill: "red", shape: "ring", text: err.message.substring(0, 32) });
+                node.status({ fill: "red", shape: "ring", text: statusError(err.message) });
                 if (done) done(err); else node.error(err, msg);
             }
         });