node-red-contrib-room-tools 1.8.15 → 1.9.0

package/control-policy.js

@@ -3,6 +3,8 @@ const escodegen = require('escodegen')
 const { initializeVisualBinding, disposeVisualBinding } = require('./panel-binding-editor')
 const { fetchWithTimeout } = require('./panel-http')
 const { createTargetMatcher } = require('./control-type-model')
+const { createRoomMeterReceiver, createMeterRenderer } = require('./meter-frame')
+const { createPanelMeterClient } = require('./panel-meter-client')
 
 const CONTROL_POLICY_MARKER = '/* ui-control-panel-control-api-v1 */'
 
@@ -157,6 +159,11 @@ function createControlPanelPolicy ({
 // generated script remains inside that supported subset.
 function buildDashboardPolicyOptionsSource (controls = [], boundPanel = null) {
   const boundControls = controls.map(({ id, type, mode }) => ({ id, type, mode }))
+  const meterMethods = boundPanel?.meter
+    ? `__createRoomMeterReceiver: ${createRoomMeterReceiver.toString()},
+    __createMeterRenderer: ${createMeterRenderer.toString()},
+    __createPanelMeterClient: ${createPanelMeterClient.toString()},`
+    : ''
   const visualMethods = boundPanel?.visual
     ? `__createTargetMatcher: ${createTargetMatcher.toString()},
     __initializeVisualBinding: ${initializeVisualBinding.toString()},
@@ -180,6 +187,7 @@ export default {
     }
   },
   methods: {
+    ${meterMethods}
     ${visualMethods}
     __panelFetch: ${fetchWithTimeout.toString()},
     __boundPanelConfig () {
@@ -304,6 +312,7 @@ export default {
       }
     },
     __disposeControlPanelPolicy () {
+      this.__boundAuthGeneration++
       this.__boundUnwatch?.()
       this.__boundUnwatch = null
       this.__clearAllBoundSettlements()
@@ -381,28 +390,28 @@ export default {
       if (!config) throw new Error('This panel has no bound login endpoint')
       this.clearBoundPanelSession()
       const generation = this.__boundAuthGeneration
-      const response = await this.__panelFetch(config.endpoint + '/login', {
+      const { response, session } = await this.__panelFetch(config.endpoint + '/login', {
         method: 'POST', credentials: 'same-origin',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ username, password })
-      })
+      }, 12000, async response => ({ response, session: response.ok ? await response.json() : null }))
       if (!response.ok) throw new Error('Panel login failed (' + response.status + ')')
-      const session = await response.json()
       if (generation !== this.__boundAuthGeneration) return null
       this.setBoundPanelSession(session)
       return session
     },
-    async restoreBoundPanelSession () {
+    async restoreBoundPanelSession (timeoutMs = 2500) {
       const config = this.__boundPanelConfig()
       if (!config) return null
       const generation = this.__boundAuthGeneration
-      const response = await this.__panelFetch(config.endpoint + '/session', { credentials: 'same-origin' })
+      const { response, session } = await this.__panelFetch(config.endpoint + '/session', {
+        credentials: 'same-origin'
+      }, timeoutMs, async response => ({ response, session: response.ok ? await response.json() : null }))
       if (generation !== this.__boundAuthGeneration) return this.__boundPanelSession
       if (!response.ok) {
         this.clearBoundPanelSession()
         return null
       }
-      const session = await response.json()
       if (generation !== this.__boundAuthGeneration) return this.__boundPanelSession
       this.setBoundPanelSession(session)
       return session
@@ -456,7 +465,7 @@ export default {
   },
   mounted () {
     this.__initializeControlPanelPolicy()
-    if (this.__boundPanelConfig()) this.restoreBoundPanelSession().catch(() => undefined)
+    ${boundPanel?.visual ? '' : 'if (this.__boundPanelConfig()) this.restoreBoundPanelSession().catch(() => undefined)'}
     ${visualMounted}
   },
   unmounted () {

package/control-type-contract.json

@@ -4,6 +4,7 @@
     "slider": { "family": "number", "delivery": "continuous" },
     "level": { "family": "number", "delivery": "continuous" },
     "volume": { "family": "number", "delivery": "continuous" },
+    "meter": { "family": "number", "delivery": "realtime", "access": "ro" },
     "dimmer": { "family": "number", "delivery": "continuous" },
     "position": { "family": "number", "delivery": "continuous" },
     "toggle": { "family": "boolean", "delivery": "discrete" },

package/control-type-model.js

@@ -1,4 +1,5 @@
 const contract = require('./control-type-contract.json')
+const { meterRoute } = require('./meter-route')
 
 
 
@@ -22,6 +23,8 @@ function createTargetMatcher (typeContract) {
     return definition.family
   }
   function compatible (adapter, target, direction, candidate = {}) {
+    if (adapter === 'meter' && !target.meter) return false
+    if (target.meter && (adapter !== 'meter' || direction !== 'read' || target.access !== 'ro')) return false
     if (target.kind !== 'param' || !families[adapter]?.includes(family(target))) return false
     if (direction === 'write' && ['meter', 'text-display'].includes(adapter)) return false
     if (!['read', 'write'].includes(direction)) return false
@@ -38,6 +41,7 @@ function controlTypeForAdapter (adapter, target) {
   if (!compatibleTarget(adapter, target, 'read') && !compatibleTarget(adapter, target, 'write')) {
     throw new Error('Target is incompatible with this control')
   }
+  if (adapter === 'meter' && target.meter) return 'meter'
   const family = targetFamily(target)
   if (family === 'number') return 'level'
   if (family === 'boolean') return 'mute'
@@ -55,7 +59,8 @@ function targetMeta (target, onebased) {
     onebased: typeof target.onebased === 'boolean' ? target.onebased : onebased,
     min: target.min, max: target.max, enums: target.enums,
     ...(target.booleanEncoding ? { booleanEncoding: target.booleanEncoding } : {}),
-    controlType: target.controlType, controlSchemaVersion: target.controlSchemaVersion
+    controlType: target.controlType, controlSchemaVersion: target.controlSchemaVersion,
+    ...(target.meter ? { meter: meterRoute(target.meter), unit: target.unit || '' } : {})
   }
 }
 

package/gateway.cjs

@@ -9,6 +9,7 @@ function createGateway ({
   room = 'room-01',
   onBoundCommand,
   onBoundLogin,
+  onAuthenticatedRequest,
   secureCookie = false,
   prefix,
   sessionTtlMs = 8 * 3600000,
@@ -193,6 +194,8 @@ function createGateway ({
         reply(res, 403, { error: 'CSRF rejected' })
         return true
       }
+      if (onAuthenticatedRequest && await onAuthenticatedRequest(req, res,
+        { token, expiry: session.expiry, room, user: username })) return true
       if (path === routePrefix + '/session' && req.method === 'GET') {
         reply(res, 200, { room, username, csrf: session.csrf })
         return true
@@ -255,6 +258,7 @@ function createGateway ({
   return {
     handler,
     boundFeedback,
+    sessionActive: token => !closed && (sessions.get(token)?.expiry || 0) > Date.now(),
     sessionSnapshot () {
       return new Map([...sessions].filter(([, session]) => session.expiry > Date.now())
         .map(([token, session]) => [token, { ...session }]))

package/managed-native-bridge.js

@@ -24,7 +24,8 @@ function panelTargets (panel) {
       const target = {
         device: binding.device, path, kind: meta.kind, type: meta.type,
         access: meta.access, onebased: meta.onebased,
-        ...(meta.booleanEncoding ? { booleanEncoding: meta.booleanEncoding } : {})
+        ...(meta.booleanEncoding ? { booleanEncoding: meta.booleanEncoding } : {}),
+        ...(meta.meter ? { meter: meta.meter } : {})
       }
       const key = JSON.stringify([target.device, target.path])
       const previous = targets.get(key)

package/meter-frame.js

@@ -0,0 +1,111 @@
+// Shared, non-reactive receivers; usable in Node and injected Vue component methods.
+function createMeterReceiver (manifest) {
+  const number = value => typeof value === 'number' && Number.isFinite(value)
+  if (manifest?.kind !== 'meter-manifest' || typeof manifest.streamId !== 'string' ||
+    !manifest.streamId.trim() || manifest.streamId.length > 255 ||
+    typeof manifest.epoch !== 'string' || !manifest.epoch || manifest.epoch.length > 128 ||
+    !Number.isInteger(manifest.layoutVersion) || manifest.layoutVersion < 1 ||
+    manifest.layoutVersion > 2147483647 || manifest.clock !== 'monotonic-ms' ||
+    !number(manifest.publishHz) || manifest.publishHz < 1 || manifest.publishHz > 60 ||
+    !Array.isArray(manifest.points) || !manifest.points.length || manifest.points.length > 256) {
+    throw Error('Invalid meter manifest')
+  }
+  const paths = new Set()
+  const points = Array.from(manifest.points, point => {
+    if (typeof point?.path !== 'string' || !/^\/[^/]/.test(point.path) ||
+      point.path.length > 1025 || paths.has(point.path) ||
+      !['integer', 'float'].includes(point.type) || !number(point.min) ||
+      !number(point.max) || point.min >= point.max ||
+      (point.type === 'integer' && (!Number.isSafeInteger(point.min) || !Number.isSafeInteger(point.max))) ||
+      typeof point.unit !== 'string' || point.unit.length > 32) throw Error('Invalid meter point')
+    paths.add(point.path)
+    return Object.freeze({ path: point.path, type: point.type, min: point.min, max: point.max, unit: point.unit })
+  })
+  const schema = Object.freeze({ ...manifest, points: Object.freeze(points) })
+  let latest = null, pending = false, closed = false
+  return {
+    manifest: schema,
+    accept (frame) {
+      if (closed || frame?.kind !== 'meter-frame' || frame.streamId !== schema.streamId ||
+        frame.epoch !== schema.epoch || frame.layoutVersion !== schema.layoutVersion ||
+        !Number.isSafeInteger(frame.seq) || frame.seq < 1 || (latest && frame.seq <= latest.seq) ||
+        !number(frame.sampleTime) || frame.sampleTime < 0 ||
+        !Array.isArray(frame.values) || frame.values.length !== points.length ||
+        !Array.isArray(frame.valid) || frame.valid.length !== points.length) return false
+      const values = [], valid = []
+      for (let index = 0; index < points.length; index++) {
+        const point = points[index], value = frame.values[index], flag = frame.valid[index]
+        if (typeof flag !== 'boolean' || (flag && (!number(value) ||
+          value < point.min || value > point.max ||
+          (point.type === 'integer' && !Number.isSafeInteger(value))))) return false
+        values.push(flag ? value : null)
+        valid.push(flag)
+      }
+      latest = Object.freeze({ kind: 'meter-frame', streamId: schema.streamId,
+        epoch: schema.epoch, seq: frame.seq, layoutVersion: schema.layoutVersion,
+        sampleTime: frame.sampleTime, values: Object.freeze(values), valid: Object.freeze(valid) })
+      pending = true
+      return true
+    },
+    snapshot () { return latest },
+    take () {
+      if (!pending) return null
+      pending = false
+      return latest
+    },
+    close () { closed = true; pending = false; latest = null }
+  }
+}
+
+function createMeterRenderer ({ receiver, requestFrame, cancelFrame, apply }) {
+  let handle = null, closed = false
+  return {
+    receive (frame) {
+      if (closed || !receiver.accept(frame)) return false
+      if (handle === null) {
+        handle = requestFrame(() => {
+          handle = null
+          const current = receiver.take()
+          if (!closed && current) apply(current)
+        })
+      }
+      return true
+    },
+    close () {
+      closed = true
+      if (handle !== null) cancelFrame(handle)
+      handle = null
+      receiver.close()
+    }
+  }
+}
+
+function createRoomMeterReceiver (layout) {
+  if (layout?.kind !== 'room-meter-layout' || typeof layout.panelId !== 'string' ||
+    typeof layout.room !== 'string' || typeof layout.epoch !== 'string' || !layout.epoch ||
+    !Array.isArray(layout.ids) || !layout.ids.length || layout.ids.length > 256 ||
+    layout.ids.some(id => typeof id !== 'string' || !id) || new Set(layout.ids).size !== layout.ids.length) {
+    throw Error('Invalid Room meter layout')
+  }
+  let latest = null, pending = false, closed = false
+  const count = layout.ids.length
+  return {
+    accept (frame) {
+      if (closed || frame?.kind !== 'room-meter-frame' || frame.panelId !== layout.panelId ||
+        frame.room !== layout.room || frame.epoch !== layout.epoch ||
+        !Number.isSafeInteger(frame.seq) || frame.seq < 1 || (latest && frame.seq <= latest.seq) ||
+        !Array.isArray(frame.values) || frame.values.length !== count ||
+        !Array.isArray(frame.valid) || frame.valid.length !== count ||
+        frame.valid.some((flag, index) => typeof flag !== 'boolean' || (flag
+          ? typeof frame.values[index] !== 'number' || !Number.isFinite(frame.values[index])
+          : frame.values[index] !== null))) return false
+      latest = { values: frame.values.slice(), valid: frame.valid.slice(), seq: frame.seq }
+      pending = true
+      return true
+    },
+    take () { if (!pending) return null; pending = false; return latest },
+    close () { closed = true; latest = null; pending = false }
+  }
+}
+
+module.exports = { createMeterReceiver, createMeterRenderer, createRoomMeterReceiver }

package/meter-route.js

@@ -0,0 +1,12 @@
+function meterRoute (value) {
+  if (value == null) return null
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+    typeof value.streamId !== 'string' || !value.streamId.trim() || value.streamId.length > 255 ||
+    ![value.eventPath, value.manifestPath].every(path => typeof path === 'string' &&
+      /^\/\/[^/]/.test(path) && path.length <= 1026) || value.eventPath === value.manifestPath) {
+    throw Error('Invalid meter delivery metadata')
+  }
+  return { streamId: value.streamId, eventPath: value.eventPath, manifestPath: value.manifestPath }
+}
+
+module.exports = { meterRoute }

package/native-binding-plan.js

@@ -1,4 +1,5 @@
 const { configuredRoutes } = require('./control-bound-protocol')
+const { meterRoute } = require('./meter-route')
 
 const supportedTypes = {
   boolean: { eventType: 'Boolean', eventOptions: { boolParamFilter: 'Any' } },
@@ -28,6 +29,7 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
   const nodes = []
   const readTargets = new Map()
   const writeTargets = new Map()
+  const meterStreams = new Map()
   const commandRules = []
   const commandWires = []
 
@@ -51,7 +53,10 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
     if (['source', 'preset'].includes(type) && !['enum', 'integer', 'string'].includes(target.type)) {
       throw new Error(`Choice control bound to ${target.type}: ${path}`)
     }
-    if (!['mute', 'power', 'level', 'dimmer', 'position', 'text', 'source', 'preset'].includes(type)) {
+    if (type === 'meter' && (!target.meter || !['integer', 'float'].includes(target.type) || target.access !== 'ro')) {
+      throw new Error(`Meter control must bind to a readonly Meter target: ${path}`)
+    }
+    if (!['mute', 'power', 'level', 'dimmer', 'position', 'meter', 'text', 'source', 'preset'].includes(type)) {
       throw new Error(`Control type requires a separate command adapter: ${type}`)
     }
     if (!['ro', 'wo', 'rw'].includes(target.access) || !target.access.includes(access)) {
@@ -88,6 +93,47 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
     if (control.mode !== 'write') {
       if (!binding.readPath) throw new Error(`Missing read path: ${id}`)
       const target = metadata(binding.device, binding.readPath, control.type, 'r')
+      if (target.meter) {
+        const meter = meterRoute(target.meter)
+        if (control.mode !== 'read' || control.adapter !== 'meter') throw Error(`Meter is read-only: ${id}`)
+        const key = JSON.stringify([target.device, meter.streamId])
+        const previous = meterStreams.get(key)
+        if (previous) {
+          if (JSON.stringify(previous.meter) !== JSON.stringify(meter) || previous.onebased !== target.onebased) {
+            throw Error(`Conflicting meter stream: ${meter.streamId}`)
+          }
+          continue
+        }
+        const index = meterStreams.size + 1
+        const statusId = `${scopeId}-meter-read-${index}`
+        const tagIds = []
+        meterStreams.set(key, { meter, onebased: target.onebased, statusId, tagIds })
+        for (const [role, path] of [['manifest', meter.manifestPath], ['frame', meter.eventPath]]) {
+          const eventId = `${scopeId}-meter-${role}-${index}`
+          const tagId = `${eventId}-tag`
+          tagIds.push(tagId)
+          const y = 540 + (index - 1) * 280 + (role === 'frame' ? 140 : 0)
+          if (role === 'manifest') nodes.push({
+            id: statusId, type: 'Status', z: subflowId, name: `Read meter manifest ${target.device}`,
+            x: 440, y: y - 60, mojo: { version: '1.0', device: [target.device],
+              parameter: path, onebased: target.onebased }, wires: [[tagId]]
+          })
+          nodes.push({ id: eventId, type: 'Event', z: subflowId,
+            name: `Watch meter ${role} ${target.device} ${meter.streamId}`, x: 440, y,
+            mojo: { version: '1.0', device: [target.device], event: path,
+              eventKind: role === 'frame' ? 'Event' : 'Parameter', paramType: 'String',
+              onebased: target.onebased }, wires: [[tagId]] })
+          nodes.push({ id: tagId, type: 'change', z: subflowId,
+            name: `Identify meter ${role} ${target.device}`, x: 1000, y,
+            rules: [
+              { t: 'set', p: 'kind', pt: 'msg', to: 'device-meter-' + role, tot: 'str' },
+              { t: 'set', p: 'device', pt: 'msg', to: target.device, tot: 'str' },
+              { t: 'set', p: 'path', pt: 'msg', to: path, tot: 'str' },
+              { t: 'set', p: 'streamId', pt: 'msg', to: meter.streamId, tot: 'str' }
+            ], wires: [[]] })
+        }
+        continue
+      }
       const key = JSON.stringify([target.device, target.path])
       if (readTargets.has(key)) continue
       const index = readTargets.size + 1
@@ -128,6 +174,8 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
   }
 
   const commandSwitchId = `${scopeId}-commands`
+  // Meter lanes follow ordinary feedback lanes without overlapping their labels.
+  for (const node of nodes) if (node.id.startsWith(`${scopeId}-meter-`)) node.y += readTargets.size * 170
   const routerId = `${scopeId}-router`
   if (commandRules.length) {
     nodes.push({
@@ -148,16 +196,17 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
     ],
     checkall: 'false', repair: false, outputs: 2,
     wires: [commandRules.length ? [commandSwitchId] : [],
-      [...readTargets.values()].map(target => target.statusId)]
+      [...readTargets.values(), ...meterStreams.values()].map(target => target.statusId)]
   })
   const subflow = {
     id: subflowId, type: 'subflow', name: `Binding bridge ${scopeId}`,
     info: 'Generated panel binding bridge. Requires a Controller node and authenticated command source.',
     category: 'panel binding',
     in: [{ x: 170, y: 150, wires: [{ id: routerId }] }],
-    out: readTargets.size
-      ? [{ x: 1290, y: Math.round((390 + (readTargets.size + 1) * 85) / 10) * 10,
-        wires: [...readTargets.values()].map(target => ({ id: target.tagId, port: 0 })) }]
+    out: readTargets.size || meterStreams.size
+      ? [{ x: meterStreams.size ? 1600 : 1290, y: Math.round((390 + (readTargets.size + meterStreams.size + 1) * 85) / 10) * 10,
+        wires: [...readTargets.values()].map(target => ({ id: target.tagId, port: 0 }))
+          .concat([...meterStreams.values()].flatMap(target => target.tagIds.map(id => ({ id, port: 0 })))) }]
       : [],
     env: [], meta: {}, color: '#96bca7'
   }
@@ -166,7 +215,8 @@ function compileNativeBindingPlan ({ panel, targets, scopeId }) {
     manifest: {
       subflowId,
       controls: routes.size,
-      nativeReads: readTargets.size,
+      nativeReads: readTargets.size + meterStreams.size,
+      nativeMeterStreams: meterStreams.size,
       nativeWrites: writeTargets.size,
       requiresController: true,
       initialReadMessage: { kind: 'read-all' }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "node-red-contrib-room-tools",
-  "version": "1.8.15",
+  "version": "1.9.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "node-red-contrib-room-tools",
-      "version": "1.8.15",
+      "version": "1.9.0",
       "license": "UNLICENSED",
       "dependencies": {
         "@vue/compiler-sfc": "3.5.42",

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "node-red-contrib-room-tools",
-  "version": "1.8.15",
+  "version": "1.9.0",
   "description": "Authenticated visual control panel binding for Node-RED and MUSE Automator",
   "license": "UNLICENSED",
-  "engines": { "node": ">=18.16.0" },
+  "engines": {
+    "node": ">=18.16.0"
+  },
   "keywords": [
     "node-red"
   ],
@@ -21,6 +23,10 @@
     "control-catalog.js",
     "control-type-contract.json",
     "control-type-model.js",
+    "meter-route.js",
+    "meter-frame.js",
+    "panel-meter.js",
+    "panel-meter-client.js",
     "panel-template-instrumentation.js",
     "panel-visual-bindings.js",
     "panel-visual-apply.js",