node-red-contrib-room-tools 1.8.9 → 1.8.16

package/panel-meter-client.js

@@ -0,0 +1,84 @@
+// Self-contained: serialized as a Vue method, with factories supplied by the node.
+function createPanelMeterClient ({ socket, panelId, room, ids, request, createReceiver,
+  createRenderer, apply, invalidate, onUnauthorized }) {
+  if (!socket) throw Error('Dashboard socket is unavailable for meter telemetry')
+  let auth = null, renderer = null, generation = 0, disposed = false
+  let retry = null, stale = null, connecting = false, delay = 500
+  const stopRendering = () => {
+    renderer?.close(); renderer = null
+    clearTimeout(stale); stale = null
+    invalidate()
+  }
+  const pause = () => {
+    generation++
+    connecting = false
+    clearTimeout(retry); retry = null
+    if (socket.connected) socket.emit('control-panel:meter-unsubscribe', panelId)
+    stopRendering()
+  }
+  const connect = async () => {
+    if (disposed || !auth || document.hidden || !socket.connected || connecting) return
+    clearTimeout(retry); retry = null
+    connecting = true
+    const expected = generation
+    try {
+      const { response, result } = await request(auth.endpoint + '/meter-ticket', {
+        method: 'POST', credentials: 'same-origin',
+        headers: { 'Content-Type': 'application/json', [auth.header]: auth.csrf },
+        body: JSON.stringify({ room, socketId: socket.id })
+      }, 5000, async response => ({ response, result: await response.json() }))
+      if (disposed || expected !== generation || document.hidden) return
+      if (response.status === 401) { pause(); auth = null; onUnauthorized(); return }
+      if (!response.ok) throw Error(result.error || 'Meter subscription failed')
+      delay = 500
+      socket.emit('control-panel:meter-subscribe', panelId, result.ticket)
+    } catch (_) {
+      if (!disposed && expected === generation && auth) {
+        retry = setTimeout(connect, delay)
+        delay = Math.min(delay * 2, 5000)
+      }
+    } finally { if (expected === generation) connecting = false }
+  }
+  const ready = layout => {
+    if (disposed || !auth || document.hidden || layout?.panelId !== panelId || layout.room !== room ||
+      !Array.isArray(layout.ids) || JSON.stringify(layout.ids) !== JSON.stringify(ids)) return
+    stopRendering()
+    try {
+      renderer = createRenderer({ receiver: createReceiver(layout),
+        requestFrame: callback => requestAnimationFrame(callback), cancelFrame: cancelAnimationFrame,
+        apply: frame => { apply(frame, ids) } })
+    } catch (_) { stopRendering() }
+  }
+  const frame = message => {
+    if (message?.panelId !== panelId || !auth || document.hidden || !renderer?.receive(message)) return
+    clearTimeout(stale)
+    stale = setTimeout(invalidate, 1500)
+  }
+  const ended = message => {
+    if (message?.panelId !== panelId) return
+    stopRendering()
+    if (auth && !disposed && !retry) retry = setTimeout(connect, 500)
+  }
+  const disconnected = () => { generation++; connecting = false; stopRendering() }
+  const visibility = () => { if (document.hidden) pause(); else void connect() }
+  socket.on('control-panel:meter-ready', ready)
+  socket.on('control-panel:meter-frame', frame)
+  socket.on('control-panel:meter-ended', ended)
+  socket.on('connect', connect)
+  socket.on('disconnect', disconnected)
+  document.addEventListener('visibilitychange', visibility)
+  return {
+    setAuth (next) { pause(); auth = next; delay = 500; if (auth) void connect() },
+    close () {
+      disposed = true; pause(); auth = null
+      socket.off('control-panel:meter-ready', ready)
+      socket.off('control-panel:meter-frame', frame)
+      socket.off('control-panel:meter-ended', ended)
+      socket.off('connect', connect)
+      socket.off('disconnect', disconnected)
+      document.removeEventListener('visibilitychange', visibility)
+    }
+  }
+}
+
+module.exports = { createPanelMeterClient }

package/panel-meter.js

@@ -0,0 +1,212 @@
+const crypto = require('node:crypto')
+const { createMeterReceiver } = require('./meter-frame')
+const { readJsonBody, replyJson } = require('./panel-http')
+const { meterRoute } = require('./meter-route')
+
+function createMeterRoom ({ room, now = Date.now, staleMs = 1000 }) {
+  const sources = new Map(), panels = new Map()
+  const ticks = new Set()
+  let timer = null
+  let generation = 0
+
+  function attach (panelId, bindings) {
+    if (panels.has(panelId)) throw Error('Meter panel already registered')
+    const points = Object.entries(bindings).filter(([, entry]) => entry.readMeta?.meter)
+      .sort(([a], [b]) => a.localeCompare(b))
+    if (!points.length || points.length > 256) throw Error('Invalid meter panel size')
+    const proposed = new Map()
+    for (const [, binding] of points) {
+      const meter = meterRoute(binding.readMeta.meter)
+      const key = JSON.stringify([binding.device, meter.streamId])
+      const previous = sources.get(key)?.route || proposed.get(key)
+      if (previous && JSON.stringify(previous) !== JSON.stringify(meter)) throw Error('Conflicting meter stream')
+      proposed.set(key, meter)
+    }
+    const projections = points.map(([id, binding]) => {
+      const meter = meterRoute(binding.readMeta.meter)
+      const key = JSON.stringify([binding.device, meter.streamId])
+      let source = sources.get(key)
+      if (source && JSON.stringify(source.route) !== JSON.stringify(meter)) throw Error('Conflicting meter stream')
+      if (!source) {
+        source = { device: binding.device, route: meter, receiver: null, receivedAt: null,
+          revision: 0, refs: new Set(), indices: new Map() }
+        sources.set(key, source)
+      }
+      source.refs.add(panelId)
+      return { id, binding, source, key, pointPath: binding.readPath.replace(/^\/\//, '/') }
+    })
+    const layout = { kind: 'room-meter-layout', panelId, room, epoch: crypto.randomBytes(16).toString('hex'),
+      ids: points.map(([id]) => id) }
+    const panel = { projections, layout, sequence: 0 }
+    panels.set(panelId, panel)
+    return layout
+  }
+
+  function accept (message) {
+    if (!['device-meter-frame', 'device-meter-manifest'].includes(message?.kind)) return false
+    const source = sources.get(JSON.stringify([message.device, message.streamId]))
+    if (!source || message.path !== (message.kind === 'device-meter-frame'
+      ? source.route.eventPath : source.route.manifestPath)) return false
+    let data = message.payload
+    // AMX Event emits its arguments object; Status emits the string directly.
+    if (data && typeof data === 'object' && Object.hasOwn(data, 'data')) data = data.data
+    if (typeof data === 'string') {
+      if (Buffer.byteLength(data) > 131072) return false
+      try { data = JSON.parse(data) } catch (_) { return false }
+    }
+    if (message.kind === 'device-meter-manifest') {
+      let receiver
+      try { receiver = createMeterReceiver(data) } catch (_) { return false }
+      if (receiver.manifest.streamId !== source.route.streamId) return false
+      const previous = source.receiver?.manifest
+      if (previous && JSON.stringify(previous) === JSON.stringify(receiver.manifest)) return true
+      if (previous?.epoch === receiver.manifest.epoch &&
+        receiver.manifest.layoutVersion <= previous.layoutVersion) return false
+      source.receiver?.close()
+      source.receiver = receiver
+      source.indices = new Map(receiver.manifest.points.map((point, index) => [point.path, index]))
+      source.receivedAt = null
+    } else {
+      if (!source.receiver?.accept(data)) return false
+      source.receivedAt = now()
+    }
+    source.revision = ++generation
+    return true
+  }
+
+  function snapshot (panelId) {
+    const panel = panels.get(panelId)
+    if (!panel) return null
+    const time = now(), values = [], valid = [], versions = new Map()
+    for (const { binding, source, key, pointPath } of panel.projections) {
+      const manifest = source.receiver?.manifest
+      const frame = source.receiver?.snapshot()
+      const index = source.indices.get(pointPath)
+      const point = manifest?.points[index]
+      const age = source.receivedAt === null ? null : Math.max(0, time - source.receivedAt)
+      const matches = point && point.type === binding.readMeta.type && point.min === binding.readMeta.min &&
+        point.max === binding.readMeta.max && point.unit === (binding.readMeta.unit || '')
+      const flag = Boolean(matches && frame?.valid[index] && age !== null && age <= staleMs)
+      values.push(flag ? frame.values[index] : null)
+      valid.push(flag)
+      versions.set(key, { device: source.device, streamId: source.route.streamId,
+        epoch: manifest?.epoch || '', seq: frame?.seq || 0, sampleTime: frame?.sampleTime ?? null, ageMs: age })
+    }
+    return { kind: 'room-meter-frame', panelId, room, epoch: panel.layout.epoch,
+      seq: ++panel.sequence, values, valid, sources: [...versions.values()] }
+  }
+
+  function revision (panelId) {
+    const panel = panels.get(panelId)
+    if (!panel) return ''
+    const time = now()
+    return panel.projections.map(({ source }) => `${source.revision}:${source.receivedAt !== null &&
+      time - source.receivedAt <= staleMs}`).join(',')
+  }
+
+  function detach (panelId) {
+    const panel = panels.get(panelId)
+    if (!panel) return
+    panels.delete(panelId)
+    for (const { source, key } of panel.projections) {
+      source.refs.delete(panelId)
+      if (!source.refs.size) { source.receiver?.close(); sources.delete(key) }
+    }
+  }
+
+  return { attach, accept, snapshot, revision, detach,
+    onTick (callback) {
+      ticks.add(callback)
+      if (!timer) { timer = setInterval(() => { for (const tick of ticks) tick() }, 1000 / 30); timer.unref?.() }
+      return () => {
+        ticks.delete(callback)
+        if (!ticks.size) { clearInterval(timer); timer = null }
+      }
+    },
+    stats: () => ({ panels: panels.size, sources: sources.size }) }
+}
+
+function createPanelMeter ({ panelId, room, bindings, hub, onSubscribe = () => {} }) {
+  const layout = hub.attach(panelId, bindings)
+  const tickets = new Map(), subscribers = new Map()
+  let closed = false, lastRevision = ''
+  const remove = socketId => {
+    const entry = subscribers.get(socketId)
+    if (entry) entry.socket.off('disconnect', entry.disconnect)
+    subscribers.delete(socketId)
+  }
+  const live = entry => entry.active() && entry.socket.connected
+  const emitFrame = (socket, frame) => socket.volatile.emit('control-panel:meter-frame', frame)
+  const prune = () => {
+    for (const [key, entry] of tickets) if (entry.expiry <= Date.now() || !entry.active()) tickets.delete(key)
+    for (const [key, entry] of subscribers) if (!live(entry)) {
+      entry.socket.emit('control-panel:meter-ended', { panelId })
+      remove(key)
+    }
+  }
+  const stopTick = hub.onTick(() => {
+    prune()
+    if (closed || !subscribers.size) return
+    const revision = hub.revision(panelId)
+    if (revision === lastRevision) return
+    lastRevision = revision
+    const frame = hub.snapshot(panelId)
+    for (const { socket } of subscribers.values()) emitFrame(socket, frame)
+  })
+
+  return {
+    async ticket (req, res, identity, active) {
+      if (!new URL(req.url, 'http://localhost').pathname.endsWith('/meter-ticket') || req.method !== 'POST') return false
+      if (closed) { replyJson(res, 503, { error: 'Meter channel unavailable' }); return true }
+      prune()
+      const body = await readJsonBody(req, 4096)
+      if (body.room !== room || typeof body.socketId !== 'string' || !body.socketId || body.socketId.length > 128) {
+        replyJson(res, 403, { error: 'Meter subscription rejected' }); return true
+      }
+      if (!req.headers.origin) { replyJson(res, 403, { error: 'Meter subscription needs Origin' }); return true }
+      // One outstanding ticket per session and socket keeps retrying clients bounded.
+      for (const [key, entry] of tickets) if (entry.token === identity.token && entry.socketId === body.socketId) tickets.delete(key)
+      if (tickets.size >= 100) { replyJson(res, 429, { error: 'Meter ticket limit reached' }); return true }
+      const ticket = crypto.randomBytes(32).toString('hex')
+      tickets.set(ticket, { token: identity.token, socketId: body.socketId,
+        expiry: Math.min(identity.expiry, Date.now() + 10000), active })
+      replyJson(res, 200, { ticket })
+      return true
+    },
+    hooks: {
+      'control-panel:meter-subscribe': (socket, id, ticket) => {
+        if (id !== panelId || closed) return
+        prune()
+        const entry = tickets.get(ticket)
+        tickets.delete(ticket)
+        if (!entry || !entry.active() || entry.expiry <= Date.now() || entry.socketId !== socket.id || !socket.connected ||
+          (!subscribers.has(socket.id) && subscribers.size >= 100)) {
+          socket.emit('control-panel:meter-ended', { panelId }); return
+        }
+        remove(socket.id)
+        const disconnect = () => remove(socket.id)
+        subscribers.set(socket.id, { socket, active: entry.active, disconnect })
+        socket.on('disconnect', disconnect)
+        socket.emit('control-panel:meter-ready', layout)
+        emitFrame(socket, hub.snapshot(panelId))
+        onSubscribe()
+      },
+      'control-panel:meter-unsubscribe': (socket, id) => { if (id === panelId) remove(socket.id) }
+    },
+    accept: message => !closed && hub.accept(message),
+    stats: () => ({ tickets: tickets.size, subscribers: subscribers.size, ...hub.stats() }),
+    close () {
+      closed = true
+      stopTick()
+      tickets.clear()
+      for (const entry of subscribers.values()) {
+        entry.socket.emit('control-panel:meter-ended', { panelId })
+        entry.socket.off('disconnect', entry.disconnect)
+      }
+      subscribers.clear()
+      hub.detach(panelId)
+    }
+  }
+}
+
+module.exports = { createMeterRoom, createPanelMeter }

package/panel-template-instrumentation.js

@@ -1,5 +1,5 @@
 const crypto = require('node:crypto')
-const { parse } = require('@vue/compiler-sfc')
+const { parse, compileTemplate } = require('@vue/compiler-sfc')
 
 const hash = value => crypto.createHash('sha256').update(value).digest('hex').slice(0, 20)
 const COMPONENT_ADAPTERS = Object.freeze({
@@ -103,6 +103,49 @@ function progressModel (node) {
     /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(model) }
 }
 
+function nativeMeterModel (node) {
+  const modelDirective = (node.props || []).find(prop => prop.type === 7 && prop.name === 'model')
+  if (modelDirective) {
+    return { model: modelDirective.exp?.content?.trim() || '', valid: !modelDirective.arg && !modelDirective.modifiers?.length &&
+      /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(modelDirective.exp?.content?.trim() || '') }
+  }
+  const bound = (node.props || []).find(prop => prop.type === 7 && prop.name === 'bind' &&
+    prop.arg?.content === 'value')
+  if (!bound) return { model: '', valid: true }
+  const model = bound.exp?.content?.trim() || ''
+  return { model, valid: !bound.modifiers?.length && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(model) }
+}
+
+function normalizeMeterVModels (format) {
+  const parsed = parse(format, { filename: 'ControlPanel.vue' })
+  if (parsed.errors.length || !parsed.descriptor.template?.ast) return format
+  const replacements = []
+  function visit (node) {
+    if (node.type === 1 && ['meter', 'progress'].includes(node.tag.toLowerCase())) {
+      const model = (node.props || []).find(prop => prop.type === 7 && prop.name === 'model')
+      if (model) {
+        const expression = model.exp?.content?.trim() || ''
+        if (model.arg || model.modifiers?.length || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(expression)) {
+          throw new Error('Native meter/progress v-model must be a simple top-level field without modifiers')
+        }
+        if ((node.props || []).some(prop => prop.type === 7 && prop.name === 'bind' &&
+          prop.arg?.content === 'value')) {
+          throw new Error('Native meter/progress v-model cannot be combined with :value')
+        }
+        replacements.push({ start: model.loc.start.offset, end: model.loc.end.offset,
+          value: `:value="${expression}"` })
+      }
+    }
+    for (const child of node.children || []) visit(child)
+  }
+  visit(parsed.descriptor.template.ast)
+  let normalized = format
+  for (const replacement of replacements.reverse()) {
+    normalized = normalized.slice(0, replacement.start) + replacement.value + normalized.slice(replacement.end)
+  }
+  return normalized
+}
+
 function pressedModel (node) {
   const directive = (node.props || []).find(prop => prop.type === 7 && prop.name === 'bind' &&
     ['aria-pressed', 'aria-checked'].includes(prop.arg?.content))
@@ -130,6 +173,19 @@ function inspectTemplate (format) {
   }
   const { descriptor, errors } = parse(format, { filename: 'ControlPanel.vue' })
   if (errors.length) throw new Error('Invalid ControlPanel template: ' + errors[0].message)
+  // Parsing alone accepts directives that Vue cannot render (for example meter v-model).
+  if (descriptor.template) {
+    const normalized = normalizeMeterVModels(format)
+    const normalizedDescriptor = parse(normalized, { filename: 'ControlPanel.vue' }).descriptor
+    const compiled = compileTemplate({ source: normalizedDescriptor.template.content,
+      filename: 'ControlPanel.vue', id: 'control-panel' })
+    if (compiled.errors.length) {
+      const error = compiled.errors[0]
+      const line = error.loc?.start?.line
+      const location = line ? ` at line ${line + descriptor.template.loc.start.line - 1}` : ''
+      throw new Error(`Invalid ControlPanel template${location}: ${error.message || error}`)
+    }
+  }
   const candidates = []
   const counts = new Map()
 
@@ -149,6 +205,7 @@ function inspectTemplate (format) {
         const display = adapter === 'text-display'
           ? displayModel(node)
           : ['v-progress-linear', 'v-progress-circular'].includes(component) ? progressModel(node)
+          : adapter === 'meter' && !component ? nativeMeterModel(node)
           : adapter === 'switch' && node.tag.toLowerCase() === 'button'
             ? pressedModel(node)
             : inputModel(node, adapter === 'range' || adapter === 'select')
@@ -161,6 +218,7 @@ function inspectTemplate (format) {
         const explicitLogic = hasDirective(node, ['on']) ||
           (node.props || []).some(prop => prop.type === 7 && prop.name === 'bind' &&
             ['value', 'checked', 'model-value', 'modelValue'].includes(prop.arg?.content) &&
+            !(adapter === 'meter' && !component && prop.arg?.content === 'value') &&
             !(['v-progress-linear', 'v-progress-circular'].includes(component) &&
               ['model-value', 'modelValue'].includes(prop.arg?.content)))
         const nestedLogic = component === 'v-radio-group' && hasNestedHandlers(node)
@@ -170,7 +228,7 @@ function inspectTemplate (format) {
         const max = staticNumericProp(node, 'max')
         const step = staticNumericProp(node, 'step')
         const dynamicBounds = (adapter === 'range' && (min.dynamic || max.dynamic || step.dynamic)) ||
-          (component === 'v-progress-linear' && max.dynamic)
+          (adapter === 'meter' && (min.dynamic || max.dynamic))
         const invalidSliderBounds = component === 'v-slider' &&
           ((min.value ?? 0) >= (max.value ?? 100) ||
             (step.value !== undefined && step.value <= 0) || attribute(node, 'step') === 'any')
@@ -258,10 +316,10 @@ function instrumentTemplate (format) {
     rendered = rendered.slice(0, insertAt) + ` data-cp-auto="${candidate.locator}"` + rendered.slice(insertAt)
   }
   return {
-    format: rendered,
+    format: normalizeMeterVModels(rendered),
     candidates: inspected.candidates.map(({ offset, ...candidate }) => candidate),
     templateHash: inspected.templateHash
   }
 }
 
-module.exports = { inspectTemplate, instrumentTemplate }
+module.exports = { inspectTemplate, instrumentTemplate, normalizeMeterVModels }

package/panel-visual-apply.js

@@ -82,7 +82,7 @@ async function applyVisualBindings ({
   }
 
   const devices = await listCatalogDevices(catalogBase, fetcher)
-  if (!Array.isArray(entries) || entries.length > 100) throw conflict('Invalid binding draft')
+  if (!Array.isArray(entries) || entries.length > 256) throw conflict('Invalid binding draft')
   const deviceIds = [...new Set(entries.map(entry => entry?.device))]
   for (const id of deviceIds) {
     if (!devices.some(device => device.id === id && device.online)) {

package/panel-visual-bindings.js

@@ -1,5 +1,6 @@
 const { inspectTemplate } = require('./panel-template-instrumentation')
 const { compatibleTarget, controlTypeForAdapter, targetMeta } = require('./control-type-model')
+const { meterRoute } = require('./meter-route')
 
 const ID = /^[A-Za-z][A-Za-z0-9._/-]{0,127}$/
 const MODES = new Set(['read', 'write', 'both'])
@@ -31,6 +32,13 @@ function visualRoutes (config) {
       (['meter', 'text-display'].includes(entry.adapter) && entry.mode !== 'read')) {
       throw new Error(`Invalid visual binding settings: ${id}`)
     }
+    if (entry.readMeta?.meter) {
+      meterRoute(entry.readMeta.meter)
+      if (entry.adapter !== 'meter' || entry.mode !== 'read' || entry.readMeta.access !== 'ro' ||
+        !['integer', 'float'].includes(entry.readMeta.type) ||
+        !Number.isFinite(entry.readMeta.min) || !Number.isFinite(entry.readMeta.max) ||
+        entry.readMeta.min >= entry.readMeta.max) throw Error(`Invalid meter binding: ${id}`)
+    }
     routes.set(id, {
       control: { id, type: entry.type, mode: entry.mode, label: entry.label,
         adapter: entry.adapter, locator: entry.locator },
@@ -41,13 +49,14 @@ function visualRoutes (config) {
 }
 
 function validatedVisualBindings ({ format, entries, devices, targetsByDevice }) {
-  if (!Array.isArray(entries) || entries.length > 100) throw new Error('At most 100 visual bindings are supported')
+  if (!Array.isArray(entries) || entries.length > 256) throw new Error('At most 256 visual bindings are supported')
   const candidates = new Map(inspectTemplate(format).candidates
     .filter(item => item.supported).map(item => [item.locator, item]))
   const knownDevices = new Map(devices.map(device => [device.id, device]))
   const result = Object.create(null)
   const used = new Set()
   const usedLocators = new Set()
+  const models = new Map()
   for (const raw of entries) {
     if (!raw || !ID.test(raw.id) || used.has(raw.id)) throw new Error('Control IDs must be unique and valid')
     used.add(raw.id)
@@ -77,6 +86,17 @@ function validatedVisualBindings ({ format, entries, devices, targetsByDevice })
     }
     const target = write || read
     const type = controlTypeForAdapter(raw.adapter, target)
+    if (read?.meter && (!Number.isFinite(read.min) || !Number.isFinite(read.max) || read.min >= read.max)) {
+      throw Error(`Meter needs a finite device range: ${raw.id}`)
+    }
+    if (candidate.model) {
+      const identity = JSON.stringify([raw.device, read?.path, write?.path])
+      const previous = models.get(candidate.model)
+      if (previous && (read?.meter || previous.meter) && previous.identity !== identity) {
+        throw Error(`Meter model "${candidate.model}" is already used by another binding; use a separate Vue model for the meter. Meter and volume controls must not share a model`)
+      }
+      models.set(candidate.model, { identity, meter: Boolean(read?.meter) })
+    }
     result[raw.id] = {
       locator: raw.locator, adapter: raw.adapter, type, label: raw.label.trim(), mode: raw.mode,
       ...(candidate.model ? { model: candidate.model } : {}),