node-red-contrib-room-tools 1.8.1 → 1.8.3-visual-binding.17

package/panel-editor-auth.js

@@ -0,0 +1,151 @@
+const crypto = require('node:crypto')
+
+function createPanelEditor ({ panelId, username, password, secureCookie, getConfig, getDevices, getTargets, apply, restoredSessions }) {
+  if (!username || !password) return null
+  const prefix = `/control-panel-edit/panels/${panelId}`
+  const cookieName = `cp_edit_${panelId.replace(/[^a-zA-Z0-9]/g, '_')}`
+  const salt = crypto.randomBytes(32)
+  const passwordHash = crypto.scryptSync(password, salt, 32)
+  const sessions = new Map()
+  if (restoredSessions instanceof Map) {
+    for (const [token, session] of restoredSessions) {
+      if (sessions.size >= 100) break
+      if (typeof token === 'string' && typeof session?.csrf === 'string' &&
+        Number.isFinite(session.expiry) && session.expiry > Date.now()) {
+        sessions.set(token, { csrf: session.csrf, expiry: session.expiry })
+      }
+    }
+  }
+  const attempts = new Map()
+  const ttl = 30 * 60 * 1000
+  let closed = false
+
+  function reply (res, status, data, headers = {}) {
+    res.writeHead(status, {
+      'Content-Type': 'application/json; charset=utf-8',
+      'Cache-Control': 'no-store',
+      'X-Content-Type-Options': 'nosniff',
+      ...headers
+    })
+    res.end(JSON.stringify(data))
+  }
+
+  function cookie (value, age) {
+    return `${cookieName}=${value}; Path=${prefix}; HttpOnly; SameSite=Strict; Max-Age=${age}${secureCookie ? '; Secure' : ''}`
+  }
+
+  function sameOrigin (req) {
+    const origin = req.headers.origin
+    if (!origin) return false
+    try {
+      const parsed = new URL(origin)
+      return parsed.host === req.headers.host &&
+        parsed.protocol === (req.socket.encrypted ? 'https:' : 'http:')
+    } catch (_) { return false }
+  }
+
+  function localOrSecure (req) {
+    const address = String(req.socket.remoteAddress || '')
+    return ['127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(address) ||
+      req.socket.encrypted === true
+  }
+
+  async function jsonBody (req) {
+    if (!String(req.headers['content-type'] || '').startsWith('application/json')) {
+      throw new Error('JSON body required')
+    }
+    if (req.body !== undefined) {
+      if (Buffer.isBuffer(req.body)) return JSON.parse(req.body.toString('utf8'))
+      if (typeof req.body === 'string') return JSON.parse(req.body)
+      if (typeof req.body === 'object' && req.body !== null && Object.keys(req.body).length) return req.body
+    }
+    let raw = ''
+    for await (const chunk of req) {
+      raw += chunk
+      if (Buffer.byteLength(raw) > 65536) throw new Error('Request too large')
+    }
+    return JSON.parse(raw)
+  }
+
+  async function handler (req, res) {
+    const path = new URL(req.url, 'http://localhost').pathname
+    if (!path.startsWith(prefix + '/')) return false
+    if (closed) { reply(res, 503, { error: 'Editor unavailable' }); return true }
+    if (!localOrSecure(req)) { reply(res, 403, { error: 'HTTPS required' }); return true }
+    if (req.method === 'POST' && !sameOrigin(req)) {
+      reply(res, 403, { error: 'Origin rejected' })
+      return true
+    }
+    const now = Date.now()
+    for (const [token, session] of sessions) if (session.expiry <= now) sessions.delete(token)
+    for (const [ip, attempt] of attempts) if (attempt.until <= now) attempts.delete(ip)
+    try {
+      if (path === prefix + '/login' && req.method === 'POST') {
+        const ip = String(req.socket.remoteAddress || 'unknown')
+        const attempt = attempts.get(ip) || { count: 0, until: now + 60000 }
+        if (attempt.count >= 10 || attempts.size > 1000) {
+          reply(res, 429, { error: 'Too many attempts' })
+          return true
+        }
+        attempt.count++
+        attempts.set(ip, attempt)
+        const body = await jsonBody(req)
+        const supplied = String(body.password || '')
+        if (supplied.length > 256) { reply(res, 401, { error: 'Invalid credentials' }); return true }
+        const test = await new Promise((resolve, reject) => crypto.scrypt(supplied, salt, 32,
+          (error, key) => error ? reject(error) : resolve(key)))
+        if (body.username !== username || !crypto.timingSafeEqual(test, passwordHash)) {
+          reply(res, 401, { error: 'Invalid credentials' })
+          return true
+        }
+        attempts.delete(ip)
+        if (sessions.size >= 100) { reply(res, 503, { error: 'Session limit reached' }); return true }
+        const token = crypto.randomBytes(32).toString('hex')
+        const csrf = crypto.randomBytes(24).toString('hex')
+        sessions.set(token, { csrf, expiry: now + ttl })
+        reply(res, 200, { csrf }, { 'Set-Cookie': cookie(token, ttl / 1000) })
+        return true
+      }
+      const token = String(req.headers.cookie || '').split(';').map(part => part.trim())
+        .find(part => part.startsWith(cookieName + '='))?.slice(cookieName.length + 1)
+      const session = sessions.get(token)
+      if (!session) { reply(res, 401, { error: 'Editor login required' }); return true }
+      if (req.method === 'POST' && req.headers['x-panel-csrf'] !== session.csrf) {
+        reply(res, 403, { error: 'CSRF rejected' })
+        return true
+      }
+      if (path === prefix + '/session' && req.method === 'GET') {
+        reply(res, 200, { csrf: session.csrf })
+      } else if (path === prefix + '/logout' && req.method === 'POST') {
+        sessions.delete(token)
+        reply(res, 200, { ok: true }, { 'Set-Cookie': cookie('', 0) })
+      } else if (path === prefix + '/config' && req.method === 'GET') {
+        reply(res, 200, await getConfig(req))
+      } else if (path === prefix + '/devices' && req.method === 'GET') {
+        reply(res, 200, { devices: await getDevices(req) })
+      } else if (path === prefix + '/targets' && req.method === 'GET') {
+        const device = new URL(req.url, 'http://localhost').searchParams.get('device')
+        reply(res, 200, { targets: await getTargets(req, device) })
+      } else if (path === prefix + '/apply' && req.method === 'POST') {
+        reply(res, 200, await apply(req, await jsonBody(req)))
+      } else {
+        reply(res, 404, { error: 'Not found' })
+      }
+      return true
+    } catch (error) {
+      reply(res, error.status || 400, { error: error.message })
+      return true
+    }
+  }
+
+  return {
+    handler,
+    sessionSnapshot () {
+      return new Map([...sessions].filter(([, session]) => session.expiry > Date.now())
+        .map(([token, session]) => [token, { ...session }]))
+    },
+    close () { closed = true; sessions.clear(); attempts.clear() }
+  }
+}
+
+module.exports = { createPanelEditor }

package/panel-template-instrumentation.js

@@ -0,0 +1,267 @@
+const crypto = require('node:crypto')
+const { parse } = require('@vue/compiler-sfc')
+
+const hash = value => crypto.createHash('sha256').update(value).digest('hex').slice(0, 20)
+const COMPONENT_ADAPTERS = Object.freeze({
+  'v-slider': 'range', 'v-switch': 'switch', 'v-checkbox': 'switch',
+  'v-select': 'select', 'v-radio-group': 'select',
+  'v-text-field': 'text-input', 'v-textarea': 'text-input',
+  'v-progress-linear': 'meter', 'v-progress-circular': 'meter'
+})
+
+function attribute (node, name) {
+  const prop = (node.props || []).find(item => item.type === 6 && item.name === name)
+  return prop?.value?.content || ''
+}
+
+function hasDirective (node, names) {
+  return (node.props || []).some(prop => prop.type === 7 && names.includes(prop.name))
+}
+
+function hasBoundAttribute (node, names) {
+  return (node.props || []).some(prop => prop.type === 7 && prop.name === 'bind' &&
+    names.includes(prop.arg?.content))
+}
+
+function hasAttribute (node, names) {
+  return (node.props || []).some(prop => prop.type === 6 && names.includes(prop.name)) ||
+    hasBoundAttribute(node, names)
+}
+
+function hasNestedHandlers (node) {
+  return (node.children || []).some(child => hasDirective(child, ['on']) || hasNestedHandlers(child))
+}
+
+function enabledBooleanProp (node, names) {
+  return (node.props || []).some(prop => {
+    if (prop.type === 6) return names.includes(prop.name)
+    return prop.type === 7 && prop.name === 'bind' && names.includes(prop.arg?.content) &&
+      prop.exp?.content?.trim() !== 'false'
+  })
+}
+
+function candidateAdapter (node) {
+  const tag = node.tag.toLowerCase()
+  if (COMPONENT_ADAPTERS[tag]) return COMPONENT_ADAPTERS[tag]
+  if (tag === 'input') {
+    const type = (attribute(node, 'type') || 'text').toLowerCase()
+    if (type === 'range' || type === 'number') return 'range'
+    if (type === 'checkbox') return 'switch'
+    if (type === 'text') return 'text-input'
+    return null
+  }
+  if (tag === 'textarea') return 'text-input'
+  if (tag === 'select') return 'select'
+  if (tag === 'button' && (attribute(node, 'aria-pressed') !== '' || attribute(node, 'role') === 'switch' ||
+    hasBoundAttribute(node, ['aria-pressed', 'aria-checked']))) return 'switch'
+  if (tag === 'meter' || tag === 'progress') return 'meter'
+  if (['span', 'strong', 'b', 'output', 'h1', 'h2', 'h3'].includes(tag) &&
+    node.children?.length === 1 && node.children[0].type === 2 &&
+    node.children[0].content.trim()) return 'text-display'
+  if (['span', 'strong', 'b', 'output', 'h1', 'h2', 'h3'].includes(tag) &&
+    node.children?.some(child => child.type === 5)) return 'text-display'
+  return null
+}
+
+function staticNumericProp (node, name) {
+  const bound = (node.props || []).find(prop => prop.type === 7 && prop.name === 'bind' &&
+    prop.arg?.content === name)
+  if (bound) {
+    const expression = bound.exp?.content?.trim() || ''
+    return /^-?(?:\d+(?:\.\d*)?|\.\d+)$/.test(expression)
+      ? { value: Number(expression), dynamic: false }
+      : { value: undefined, dynamic: true }
+  }
+  const value = attribute(node, name)
+  if (value === '' || (name === 'step' && value === 'any')) return { value: undefined, dynamic: false }
+  const numeric = Number(value)
+  return { value: numeric, dynamic: !Number.isFinite(numeric) }
+}
+
+function displayModel (node) {
+  const dynamic = (node.children || []).filter(child => child.type === 5)
+  if (!dynamic.length) return { model: '', valid: true }
+  const expression = dynamic.length === 1 ? dynamic[0].content?.content?.trim() : ''
+  return { model: expression, valid: /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(expression) }
+}
+
+function inputModel (node, allowNumber = false) {
+  const directive = (node.props || []).find(prop => prop.type === 7 && prop.name === 'model')
+  if (!directive) return { model: '', valid: true }
+  const model = directive.exp?.content?.trim() || ''
+  const modifiers = (directive.modifiers || []).map(item => typeof item === 'string' ? item : item.content)
+  return { model, valid: !directive.arg && modifiers.every(item => allowNumber && item === 'number') &&
+    /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(model) }
+}
+
+function progressModel (node) {
+  const bound = (node.props || []).find(prop => prop.type === 7 && prop.name === 'bind' &&
+    ['model-value', 'modelValue'].includes(prop.arg?.content))
+  if (!bound) return inputModel(node)
+  const model = bound.exp?.content?.trim() || ''
+  return { model, valid: !hasDirective(node, ['model']) && !bound.modifiers?.length &&
+    /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(model) }
+}
+
+function pressedModel (node) {
+  const directive = (node.props || []).find(prop => prop.type === 7 && prop.name === 'bind' &&
+    ['aria-pressed', 'aria-checked'].includes(prop.arg?.content))
+  if (!directive) return { model: '', valid: true }
+  const model = directive.exp?.content?.trim() || ''
+  return { model, valid: !directive.modifiers?.length &&
+    /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(model) }
+}
+
+function openingTagEnd (source, start) {
+  let quote = ''
+  for (let index = start; index < source.length; index++) {
+    const char = source[index]
+    if (quote) {
+      if (char === quote) quote = ''
+    } else if (char === '"' || char === "'") quote = char
+    else if (char === '>') return index
+  }
+  throw new Error('Unclosed element in ControlPanel template')
+}
+
+function inspectTemplate (format) {
+  if (typeof format !== 'string' || format.length > 1024 * 1024) {
+    throw new Error('ControlPanel template must be text under 1 MB')
+  }
+  const { descriptor, errors } = parse(format, { filename: 'ControlPanel.vue' })
+  if (errors.length) throw new Error('Invalid ControlPanel template: ' + errors[0].message)
+  const candidates = []
+  const counts = new Map()
+
+  function visit (node, repeated = false) {
+    if (node.type === 1) {
+      if (node.tag.toLowerCase().startsWith('v-') && node.isSelfClosing) {
+        throw new Error(`Vuetify component <${node.tag}> needs an explicit closing tag in Dashboard templates`)
+      }
+      const insideRepeat = repeated || hasDirective(node, ['for'])
+      const adapter = candidateAdapter(node)
+      const customAttribute = (node.props || []).some(prop =>
+        (prop.type === 6 && prop.name.startsWith('data-cp-')) ||
+        (prop.type === 7 && prop.name === 'bind' && prop.arg?.content?.startsWith('data-cp-')))
+      if (customAttribute) throw new Error('ControlPanel-specific data-cp-* attributes are no longer supported')
+      if (adapter) {
+        const component = COMPONENT_ADAPTERS[node.tag.toLowerCase()] ? node.tag.toLowerCase() : ''
+        const display = adapter === 'text-display'
+          ? displayModel(node)
+          : ['v-progress-linear', 'v-progress-circular'].includes(component) ? progressModel(node)
+          : adapter === 'switch' && node.tag.toLowerCase() === 'button'
+            ? pressedModel(node)
+            : inputModel(node, adapter === 'range' || adapter === 'select')
+        const source = format.slice(node.loc.start.offset, openingTagEnd(format, node.loc.start.offset) + 1)
+        const stableName = attribute(node, 'id') || attribute(node, 'name')
+        const locator = stableName
+          ? `name:${hash(node.tag + ':' + stableName)}`
+          : `tag:${hash(source.replace(/\s+/g, ' ').trim() +
+            (adapter === 'text-display' ? ':' + (display.model || node.children[0]?.content?.trim() || '') : ''))}`
+        const explicitLogic = hasDirective(node, ['on']) ||
+          (node.props || []).some(prop => prop.type === 7 && prop.name === 'bind' &&
+            ['value', 'checked', 'model-value', 'modelValue'].includes(prop.arg?.content) &&
+            !(['v-progress-linear', 'v-progress-circular'].includes(component) &&
+              ['model-value', 'modelValue'].includes(prop.arg?.content)))
+        const nestedLogic = component === 'v-radio-group' && hasNestedHandlers(node)
+        const unboundedNumber = node.tag.toLowerCase() === 'input' &&
+          attribute(node, 'type').toLowerCase() === 'number'
+        const min = staticNumericProp(node, 'min')
+        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)
+        const invalidSliderBounds = component === 'v-slider' &&
+          ((min.value ?? 0) >= (max.value ?? 100) ||
+            (step.value !== undefined && step.value <= 0) || attribute(node, 'step') === 'any')
+        const customSwitchValues = component && adapter === 'switch' &&
+          ((node.props || []).some(prop => prop.type === 6 &&
+            ['multiple', 'value', 'true-value', 'false-value'].includes(prop.name)) ||
+            hasBoundAttribute(node, ['multiple', 'value', 'true-value', 'false-value']))
+        const unsupportedSelect = component === 'v-select' &&
+          enabledBooleanProp(node, ['multiple', 'return-object', 'clearable'])
+        const unsupportedRadio = component === 'v-radio-group' &&
+          (hasAttribute(node, ['multiple', 'type']) || nestedLogic)
+        const unsupportedTextType = component === 'v-text-field' &&
+          ((attribute(node, 'type') && attribute(node, 'type') !== 'text') ||
+            hasBoundAttribute(node, ['type']))
+        const unsupportedProgress = component === 'v-progress-linear' &&
+          (enabledBooleanProp(node, ['indeterminate', 'clickable']) ||
+            hasAttribute(node, ['min', 'step']) ||
+            (max.value !== undefined && max.value <= 0))
+        const unsupportedCircular = component === 'v-progress-circular' &&
+          (enabledBooleanProp(node, ['indeterminate']) || hasAttribute(node, ['min', 'max', 'step']))
+        const candidate = {
+          locator, adapter,
+          ...(component ? { component } : {}),
+          label: attribute(node, 'aria-label') || attribute(node, 'label') || attribute(node, 'title') ||
+            stableName || display.model || (adapter === 'text-display' ? node.children[0]?.content?.trim() : '') || node.tag,
+          ...(display.model ? { model: display.model } : {}),
+          ...(adapter === 'range' || adapter === 'meter' ? {
+            min: ['v-progress-linear', 'v-progress-circular'].includes(component) ? 0
+              : min.value !== undefined ? min.value : unboundedNumber ? undefined : 0,
+            max: component === 'v-progress-circular' ? 100
+              : max.value !== undefined ? max.value : unboundedNumber ? undefined
+              : adapter === 'meter' && !component ? 1 : 100,
+            step: ['v-progress-linear', 'v-progress-circular'].includes(component) ? 'any'
+              : step.value !== undefined ? String(step.value) : attribute(node, 'step') ||
+                (adapter === 'meter' ? 'any' : '1')
+          } : {}),
+          ...(attribute(node, 'data-unit') ? { unit: attribute(node, 'data-unit') } : {}),
+          line: node.loc.start.line,
+          supported: !insideRepeat && !explicitLogic && display.valid && !dynamicBounds &&
+            !invalidSliderBounds &&
+            !customSwitchValues && !unsupportedSelect && !unsupportedRadio &&
+            !unsupportedTextType && !unsupportedProgress && !unsupportedCircular &&
+            (!component || Boolean(display.model)),
+          reason: insideRepeat ? 'Repeated controls need a stable item identity' :
+            explicitLogic ? 'Controls with existing handlers or reactive value bindings need a dedicated adapter' :
+              !display.valid ? (adapter === 'text-display' ? 'Dynamic text needs one writable data field' :
+                'Only a simple Vue v-model field is supported') :
+                dynamicBounds ? 'Dynamic numeric bounds need a dedicated adapter' :
+                  invalidSliderBounds ? 'Slider min, max, and step must form a valid range' :
+                  customSwitchValues ? 'Custom switch values need a dedicated adapter' :
+                    unsupportedSelect ? 'Only a single scalar Vuetify selection is supported' :
+                      unsupportedRadio ? 'Radio groups need scalar values without separate handlers' :
+                      unsupportedTextType ? 'Only text Vuetify fields are supported' :
+                        unsupportedProgress ? 'Progress needs a determinate positive range' :
+                          unsupportedCircular ? 'Circular progress uses a determinate 0-100 range' :
+                    component && !display.model ? 'Vuetify controls need a simple Vue v-model field' : ''
+        }
+        candidates.push({ ...candidate, offset: openingTagEnd(format, node.loc.start.offset) })
+        counts.set(locator, (counts.get(locator) || 0) + 1)
+      }
+      for (const child of node.children || []) visit(child, insideRepeat)
+      return
+    }
+    for (const child of node.children || []) visit(child, repeated)
+    for (const branch of node.branches || []) visit(branch, repeated)
+  }
+
+  if (descriptor.template?.ast) visit(descriptor.template.ast)
+  for (const candidate of candidates) {
+    if (counts.get(candidate.locator) > 1) {
+      candidate.supported = false
+      candidate.reason = 'This element is ambiguous; give it a unique HTML id or name'
+    }
+  }
+  return { candidates, templateHash: hash(format) }
+}
+
+function instrumentTemplate (format) {
+  const inspected = inspectTemplate(format)
+  let rendered = format
+  for (const candidate of [...inspected.candidates].reverse()) {
+    const before = rendered.slice(0, candidate.offset)
+    const selfClosing = /\/\s*$/.test(before)
+    const insertAt = selfClosing ? before.lastIndexOf('/') : candidate.offset
+    rendered = rendered.slice(0, insertAt) + ` data-cp-auto="${candidate.locator}"` + rendered.slice(insertAt)
+  }
+  return {
+    format: rendered,
+    candidates: inspected.candidates.map(({ offset, ...candidate }) => candidate),
+    templateHash: inspected.templateHash
+  }
+}
+
+module.exports = { inspectTemplate, instrumentTemplate }

package/panel-visual-apply.js

@@ -0,0 +1,127 @@
+const fs = require('node:fs')
+const { inspectTemplate } = require('./panel-template-instrumentation')
+const { validatedVisualBindings } = require('./panel-visual-bindings')
+const { listCatalogDevices, listCatalogTargets } = require('./control-catalog')
+const { configuredRoutes } = require('./control-bound-protocol')
+const { provisionManagedBridges } = require('./managed-native-bridge')
+const { backupFlow, flowLocation, localDirectory } = require('./managed-bridge-admin')
+
+function conflict (message) {
+  const error = new Error(message)
+  error.status = 409
+  return error
+}
+
+function adminUrl (localPort) {
+  if (!Number.isInteger(localPort) || localPort < 1 || localPort > 65535) {
+    throw new Error('Local Automator port unavailable')
+  }
+  return `http://127.0.0.1:${localPort}/red/flows`
+}
+
+async function getSnapshot (localPort, fetcher = fetch) {
+  const response = await fetcher(adminUrl(localPort), {
+    headers: { 'Node-RED-API-Version': 'v2' },
+    signal: AbortSignal.timeout(10000)
+  })
+  if (!response.ok) throw new Error(`Automator Flow read failed (${response.status})`)
+  const snapshot = await response.json()
+  if (typeof snapshot.rev !== 'string' || !Array.isArray(snapshot.flows)) {
+    throw new Error('Automator did not return a versioned Flow')
+  }
+  return snapshot
+}
+
+function findPanel (snapshot, panelId) {
+  const panel = snapshot.flows.find(node => node.id === panelId)
+  if (!panel || panel.type !== 'ui-control-panel') {
+    throw conflict('Visual editor is not enabled for this panel')
+  }
+  if (String(panel.z || '').startsWith('subflow:') ||
+    snapshot.flows.some(node => node.id === panel.z && node.type === 'subflow')) {
+    throw conflict('Editing a shared subflow template from the page is not supported')
+  }
+  return panel
+}
+
+function editorConfig (snapshot, panelId) {
+  const panel = findPanel(snapshot, panelId)
+  const inspected = inspectTemplate(panel.format)
+  let bindings = panel.visualBindings || '{}'
+  if (typeof bindings === 'string') bindings = JSON.parse(bindings)
+  return {
+    rev: snapshot.rev,
+    templateHash: inspected.templateHash,
+    candidates: inspected.candidates,
+    bindings: Object.entries(bindings).map(([id, entry]) => ({ id, ...entry })),
+    room: panel.boundRoom || ''
+  }
+}
+
+async function applyVisualBindings ({
+  panelId, rev, templateHash, entries, userDir, remoteAddress, localPort,
+  catalogBase, fetcher = fetch
+}) {
+  localDirectory(userDir, remoteAddress)
+  if (!catalogBase) throw conflict('Device catalog is unavailable')
+  const snapshot = await getSnapshot(localPort, fetcher)
+  if (snapshot.rev !== rev) throw conflict('Flow changed; refresh the visual editor')
+  const panel = findPanel(snapshot, panelId)
+  if (inspectTemplate(panel.format).templateHash !== templateHash) {
+    throw conflict('Template changed; refresh the visual editor')
+  }
+  const location = flowLocation(fs.realpathSync(userDir))
+  if (JSON.stringify(JSON.parse(fs.readFileSync(location.flowFile, 'utf8'))) !== JSON.stringify(snapshot.flows)) {
+    throw conflict('Deployed Flow differs from the active project file')
+  }
+
+  const devices = await listCatalogDevices(catalogBase, fetcher)
+  if (!Array.isArray(entries) || entries.length > 100) 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)) {
+      throw conflict(`Device is unavailable: ${id}`)
+    }
+  }
+  const targetsByDevice = new Map(await Promise.all(deviceIds.map(async id =>
+    [id, await listCatalogTargets(catalogBase, id, fetcher)])))
+  const validated = validatedVisualBindings({ format: panel.format, entries, devices, targetsByDevice })
+  const next = structuredClone(snapshot.flows)
+  const nextPanel = next.find(node => node.id === panelId)
+  nextPanel.visualBindings = JSON.stringify(validated)
+  nextPanel.nativeBridge = configuredRoutes(nextPanel).size > 0
+  const provisioned = provisionManagedBridges(next, { panelId })
+
+  const latest = await getSnapshot(localPort, fetcher)
+  if (latest.rev !== snapshot.rev) throw conflict('Flow changed during validation; refresh and retry')
+  if (JSON.stringify(JSON.parse(fs.readFileSync(location.flowFile, 'utf8'))) !== JSON.stringify(snapshot.flows)) {
+    throw conflict('Active project changed during validation')
+  }
+  const backupDir = backupFlow(location, snapshot.rev, snapshot.flows)
+  const response = await fetcher(adminUrl(localPort), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Node-RED-API-Version': 'v2',
+      'Node-RED-Deployment-Type': 'nodes'
+    },
+    body: JSON.stringify({ rev: snapshot.rev, flows: provisioned.flows }),
+    signal: AbortSignal.timeout(20000)
+  })
+  if (!response.ok) throw conflict(`Automator rejected the binding update (${response.status})`)
+  const applied = await response.json().catch(() => ({}))
+  let confirmed
+  for (let attempt = 0; attempt < 5; attempt++) {
+    confirmed = await getSnapshot(localPort, fetcher)
+    const confirmedPanel = confirmed.flows.find(node => node.id === panelId)
+    if (confirmedPanel?.visualBindings === nextPanel.visualBindings &&
+      confirmedPanel.bridgeRevisionApplied === provisioned.flows.find(node => node.id === panelId)?.bridgeRevisionApplied) {
+      return { ok: true, rev: confirmed.rev, backupDir, updated: provisioned.updated }
+    }
+    if (confirmed.rev !== snapshot.rev && confirmed.rev !== applied.rev) break
+    if (attempt < 4) await new Promise(resolve => setTimeout(resolve, 200))
+  }
+  throw conflict('Automator did not confirm the binding update; refresh before retrying')
+}
+
+module.exports = { adminUrl, applyVisualBindings, editorConfig, getSnapshot }

package/panel-visual-bindings.js

@@ -0,0 +1,95 @@
+const { inspectTemplate } = require('./panel-template-instrumentation')
+const { compatibleTarget, controlTypeForAdapter, targetMeta } = require('./control-type-model')
+
+const ID = /^[A-Za-z][A-Za-z0-9._/-]{0,127}$/
+const MODES = new Set(['read', 'write', 'both'])
+
+function parseVisualBindings (config) {
+  let raw = config.visualBindings || '{}'
+  if (typeof raw === 'string') raw = JSON.parse(raw)
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('Invalid visual bindings')
+  return raw
+}
+
+function visualRoutes (config) {
+  const saved = parseVisualBindings(config)
+  const candidates = inspectTemplate(config.format).candidates
+  const locators = new Map(candidates.filter(item => item.supported).map(item => [item.locator, item]))
+  const routes = new Map()
+  const usedLocators = new Set()
+  for (const [id, entry] of Object.entries(saved)) {
+    if (!ID.test(id) || !entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      throw new Error(`Invalid visual control: ${id}`)
+    }
+    const candidate = locators.get(entry.locator)
+    if (!candidate || candidate.adapter !== entry.adapter) {
+      throw new Error(`Visual control moved or became ambiguous: ${id}`)
+    }
+    if (usedLocators.has(entry.locator)) throw new Error(`Duplicate visual control locator: ${id}`)
+    usedLocators.add(entry.locator)
+    if (!MODES.has(entry.mode) || !entry.type || !entry.label ||
+      (['meter', 'text-display'].includes(entry.adapter) && entry.mode !== 'read')) {
+      throw new Error(`Invalid visual binding settings: ${id}`)
+    }
+    routes.set(id, {
+      control: { id, type: entry.type, mode: entry.mode, label: entry.label,
+        adapter: entry.adapter, locator: entry.locator },
+      binding: entry
+    })
+  }
+  return routes
+}
+
+function validatedVisualBindings ({ format, entries, devices, targetsByDevice }) {
+  if (!Array.isArray(entries) || entries.length > 100) throw new Error('At most 100 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()
+  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)
+    const candidate = candidates.get(raw.locator)
+    if (!candidate || candidate.adapter !== raw.adapter) throw new Error(`Control changed: ${raw.id}`)
+    if (usedLocators.has(raw.locator)) throw new Error(`One element cannot have two bindings: ${raw.id}`)
+    usedLocators.add(raw.locator)
+    if (!MODES.has(raw.mode) || (['meter', 'text-display'].includes(raw.adapter) && raw.mode !== 'read')) {
+      throw new Error(`Invalid binding mode: ${raw.id}`)
+    }
+    if (typeof raw.label !== 'string' || !raw.label.trim() || raw.label.length > 80) {
+      throw new Error(`Invalid control label: ${raw.id}`)
+    }
+    if (!knownDevices.has(raw.device)) throw new Error(`Unknown device: ${raw.id}`)
+    const targets = targetsByDevice.get(raw.device)
+    if (!targets) throw new Error(`Device catalog unavailable: ${raw.device}`)
+    const byPath = new Map(targets.map(target => [target.path, target]))
+    const write = raw.mode === 'read' ? null : byPath.get(raw.writePath)
+    const read = raw.mode === 'write' ? null : byPath.get(raw.readPath)
+    if ((raw.mode !== 'read' && !write) || (raw.mode !== 'write' && !read)) {
+      throw new Error(`Target disappeared: ${raw.id}`)
+    }
+    if (write && !compatibleTarget(raw.adapter, write, 'write', candidate)) throw new Error(`Incompatible write target: ${raw.id}`)
+    if (read && !compatibleTarget(raw.adapter, read, 'read', candidate)) throw new Error(`Incompatible feedback target: ${raw.id}`)
+    if (write && read && controlTypeForAdapter(raw.adapter, write) !== controlTypeForAdapter(raw.adapter, read)) {
+      throw new Error(`Read and write targets have different types: ${raw.id}`)
+    }
+    const target = write || read
+    const type = controlTypeForAdapter(raw.adapter, target)
+    result[raw.id] = {
+      locator: raw.locator, adapter: raw.adapter, type, label: raw.label.trim(), mode: raw.mode,
+      ...(candidate.model ? { model: candidate.model } : {}),
+      ...(candidate.component ? { component: candidate.component } : {}),
+      ...(['range', 'meter'].includes(raw.adapter)
+        ? { uiRange: { min: candidate.min, max: candidate.max, step: candidate.step } } : {}),
+      device: raw.device,
+      writePath: write?.path || '', readPath: read?.path || '',
+      ...(write ? { writeMeta: targetMeta(write, raw.onebased) } : {}),
+      ...(read ? { readMeta: targetMeta(read, raw.onebased) } : {})
+    }
+  }
+  return result
+}
+
+module.exports = { parseVisualBindings, visualRoutes, validatedVisualBindings }

package/room-gateway.html

@@ -1,21 +0,0 @@
-<script type="text/javascript">
-RED.nodes.registerType('room-gateway',{
- category:'Room Tools',color:'#a8d5c3',defaults:{name:{value:''},room:{value:'room-01',required:true},secureCookie:{value:false}},
- credentials:{username:{type:'text'},password:{type:'password'}},inputs:1,outputs:1,icon:'font-awesome/fa-lock',
- paletteLabel:'区域权限网关',label:function(){return this.name||'区域权限网关'},inputLabels:'设备反馈 kind=state',outputLabels:'已验证的控制指令'
-})
-</script>
-<script type="text/html" data-template-name="room-gateway">
-<div class="form-row"><label for="node-input-name">名称</label><input id="node-input-name" type="text"></div>
-<div class="form-row"><label for="node-input-room">区域 ID</label><input id="node-input-room" type="text"></div>
-<div class="form-row"><label for="node-input-username">登录账号</label><input id="node-input-username" type="text" autocomplete="off"></div>
-<div class="form-row"><label for="node-input-password">登录密码</label><input id="node-input-password" type="password" autocomplete="new-password"></div>
-<div class="form-row"><label for="node-input-secureCookie">HTTPS</label><input id="node-input-secureCookie" type="checkbox" style="width:auto">仅通过 HTTPS 发送会话 Cookie</div>
-<p>密码至少 12 个字符。每个区域 ID 只能部署一个网关，账号只能访问该网关配置的区域。</p>
-</script>
-<script type="text/html" data-help-name="room-gateway">
-<p>Template 通过同源 /room-panel-api/regions/&lt;区域 ID&gt; 登录和发送控制请求；ui-control-panel 登录后自动订阅该区域的实时设备反馈。Template 输出不再用于控制设备。</p>
-<p>本节点输出已授权消息，连接原来的 Switch。设备反馈必须含 room、kind: state、topic 和 payload，接入本节点输入，不接 Template。</p>
-<p>网关会保存每个已关联控件最后收到的真实设备状态。页面在线时通过实时反馈流立即推送；页面未登录时继续缓存，登录后在反馈流首帧发送完整状态快照。</p>
-<p>公开状态只包含设备反馈，不会把刚接受的控制目标冒充实际状态。Node-RED 编辑器属于管理员入口，部署时应独立保护。生产 iPad 访问请配置 HTTPS 并启用 HTTPS Cookie。</p>
-</script>