signalk-czone 0.3.0-beta.15 → 0.3.0-beta.17

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.3.0-beta.17
+
+- Prompts for Signal K login when CZone circuit requests are unauthorized, returning to the webapp after sign-in (#34).
+- Shows permission and circuit-loading errors with a retry option instead of waiting indefinitely for Signal K.
+
+## 0.3.0-beta.16
+
+- Adds an opt-in Victron GX switch pane for CZone circuits on the GX, Remote Console and VRM (#33).
+- Preserves write-control and confirmation rules, synchronises observed state, and keeps GX names and grouping settings.
+- Resets on circuits when changing to momentary mode; refuses blocked changes and restores the previous type if CZone does not confirm OFF.
+
 ## 0.3.0-beta.15
 
 - Preserves plugin settings when uploading a ZCF or selecting a network configuration (#32).

package/README.md

@@ -235,6 +235,18 @@ The switch follows the CZone circuit, and the circuit follows the switch when it
 
 The switch is read every 2 s; a CZone change is acted on as its status message arrives. `GET /plugins/signalk-czone/bridge/status` shows each link; `/bridge/outputs` lists the GX's outputs; `/bridge/shelly?host=&channel=` asks a Shelly. Tested on a bench (Shelly PM1 both ways) and on a boat (GX relay 2 switched from a CZone display; the alarm relay refused).
 
+## Victron switch pane
+
+On a Victron GX (Venus OS 3.60 or later), tick **Show CZone circuits in the Victron switch pane** in the configuration panel and the circuits appear as switches on the GX touch screen, Remote Console and VRM. The plugin registers `com.victronenergy.switch.czone` on the GX's D-Bus, following Victron's switchable-output API.
+
+- **Which circuits:** those the webapp lists, one card per CZone category (the first sub-category, in a fixed priority, when there are several; DC or AC when there are none). A circuit linked to a third-party switch is left out, since that switch is already in the pane.
+- **Both ways:** a tap in the pane switches the circuit with the same code as a Signal K PUT, so it needs **Enable CZone read/write control**, and a circuit set to confirm before turning off (on) is not turned off (on) from the pane unless other apps are allowed to; the pane's switch goes back. A change made anywhere else shows in the pane, from the plugin's own decoded 65284 state, checked every two seconds.
+- **Label:** the circuit name, plus the current while it is on ("Freezer (2.9 A)"; untick **Show circuit current** to leave it off). A reading that only wobbles does not change the label, since every rename makes the GX re-sort its lists. Names, groups, types and the device's name can be edited on the GX and are kept (`victron-switches.json` in the plugin's data folder).
+- **Device list:** Settings > Devices lists each switch as "CZone: name".
+- `GET /plugins/signalk-czone/victron/status` reports whether it is running, which circuits the pane has as on, any that disagree with the plugin, and the last few requests from the pane.
+
+Off a GX, or without `dbus-native` (an optional dependency), it reports that D-Bus is not available and the rest of the plugin is unaffected.
+
 ## Installation
 
 The plugin installs the pinned `signalk-czone-zcf@0.1.0-beta.2` npm dependency automatically. No separate parser installation or Git checkout is required.
@@ -261,7 +273,7 @@ npm install signalk-czone@latest --omit=dev --ignore-scripts
 
 Restart Signal K and follow the configuration steps above. For Docker or appliance installations, use the corresponding container/configuration directory and restart method.
 
-For installation from a maintainer-provided npm tarball, run `npm install /path/to/signalk-czone-0.3.0-beta.15.tgz --omit=dev --ignore-scripts` from the same configuration directory. Its pinned parser dependency must already be published to npm. Do not simply extract the plugin into `node_modules`: that does not install dependencies.
+For installation from a maintainer-provided npm tarball, run `npm install /path/to/signalk-czone-0.3.0-beta.16.tgz --omit=dev --ignore-scripts` from the same configuration directory. Its pinned parser dependency must already be published to npm. Do not simply extract the plugin into `node_modules`: that does not install dependencies.
 
 ### Publishing (maintainers)
 

package/index.js

@@ -13,6 +13,7 @@ const confirmOffLib = require('./lib/confirm-off')
 const { createBridge, bridgeEntries } = require('./lib/bridge')
 const { createShellyDriver } = require('./lib/bridge/shelly')
 const { createVictronDriver } = require('./lib/bridge/victron')
+const { createVictronSwitches } = require('./lib/victron/switches')
 
 const MAX_UPLOAD_BYTES = 1024 * 1024
 const CZONE_CONFIG_BLOCK_HEADER = 23
@@ -151,6 +152,44 @@ module.exports = function (app) {
     },
     drivers: bridgeDrivers
   })
+  // Victron switch pane (lib/victron/switches): the CZone circuits as
+  // switches on the GX touch screen, Remote Console and VRM. Off unless
+  // ticked. A tap there switches the circuit through the same code as a
+  // Signal K PUT, so "Enable CZone read/write control" and the confirm-before
+  // rules apply; the state shown is the plugin's own decoded 65284 state.
+  const switchPane = createVictronSwitches(app, {
+    log: m => log(m),
+    version: require('./package.json').version,
+    getCurrent: skPath => {
+      const m = /^electrical\.czone\.([^.]+)\.current$/.exec(skPath || '')
+      const c = m && mapping && mapping.circuits.find(x => x.slug === m[1])
+      const st = c && runtimeState.get(c.name)
+      return st && Number.isFinite(st.current) ? st.current : null
+    },
+    controls: () => ({
+      state: (slug, on) => {
+        const c = circuitByName(slug)
+        if (on) refuseUnconfirmedOn(c)
+        else refuseUnconfirmedOff(c)
+        sendCircuitState(c, on)
+        const st = runtimeState.get(c.name)
+        if (st) st.lastRequested = on ? 'ON' : 'OFF'
+      },
+      brightness: (slug, normalized) => {
+        const c = circuitByName(slug)
+        const st = runtimeState.get(c.name)
+        if (normalized <= 0) refuseUnconfirmedOff(c)
+        else if (!st || st.state !== 'ON') refuseUnconfirmedOn(c)
+        sendCircuitBrightness(c, normalized)
+        if (st) st.lastRequestedPercent = Math.round(normalized * 100)
+      },
+      getState: slug => {
+        const c = mapping && mapping.circuits.find(x => x.slug === slug)
+        const st = c && runtimeState.get(c.name)
+        return st && st.statusObserved ? { state: st.state, percent: st.percent } : null
+      }
+    })
+  })
   let monitoringRuntime = null
   // Trend recording of circuit current (see lib/trends).
   let trends = null
@@ -1309,6 +1348,18 @@ module.exports = function (app) {
           default: false,
           description: 'Other Signal K apps switch with a PUT and cannot ask "are you sure?". Unticked, an off from them is refused with a message; the circuit can still be turned off from the webapp or a CZone keypad.'
         },
+        victronSwitches: {
+          type: 'boolean',
+          title: 'Show CZone circuits in the Victron switch pane',
+          default: false,
+          description: 'Victron GX only (Venus OS 3.60 or later). The circuits appear as switches on the GX touch screen, Remote Console and VRM, one card per CZone category. Switching there needs CZone read/write control enabled, and circuits set to confirm before turning off (on) are not turned off (on) from there unless other apps are allowed to.'
+        },
+        victronSwitchCurrent: {
+          type: 'boolean',
+          title: 'Show circuit current in the switch pane',
+          default: true,
+          description: 'Adds the current to a switch\'s label while the circuit is on, for example "Freezer (2.9 A)".'
+        },
         bridges: {
           type: 'array',
           title: 'Third-party switches',
@@ -1350,6 +1401,7 @@ module.exports = function (app) {
       })
       trends.start()
       startBridge()
+      switchPane.start(settings, mapping).catch(err => log(`Victron switch pane: ${err.message}`))
 
       const ready = (reason = 'nmea2000OutAvailable event') => {
         nmeaReady = true
@@ -1426,6 +1478,7 @@ module.exports = function (app) {
       if (trends) trends.stop()
       trends = null
       bridge.stop()
+      switchPane.stop()
       closeBridgeBus()
       reassembler = null
       configFastPacket = null
@@ -1544,6 +1597,7 @@ module.exports = function (app) {
 
       // Third-party switches: link status, the GX's outputs, a Shelly test.
       router.get('/bridge/status', (_req, res) => res.json({ links: bridge.status() }))
+      router.get('/victron/status', (_req, res) => res.json(switchPane.status()))
       router.get('/bridge/outputs', (_req, res) => {
         bridgeDrivers.victron.list()
           .then(outputs => res.json({ available: true, outputs }))
@@ -1733,5 +1787,7 @@ module.exports = function (app) {
 
   // For tests: run one bridge poll now instead of waiting for its timer.
   Object.defineProperty(plugin, '_bridgePoll', { value: () => bridge.poll(), enumerable: false })
+  // For tests: the Victron switch pane.
+  Object.defineProperty(plugin, '_switchPane', { value: switchPane, enumerable: false })
   return plugin
 }

package/lib/victron/switches.js

@@ -0,0 +1,635 @@
+'use strict'
+
+// CZone circuits in the Venus OS switch pane (Venus OS 3.60+).
+//
+// Registers com.victronenergy.switch.czone on the GX's system D-Bus
+// with one /SwitchableOutput/<slug>/… channel per ZCF circuit, following
+// Victron's switch API (github.com/victronenergy/venus/wiki/dbus#switch):
+//   State (0/1), Status (0x00 off / 0x09 on), Name, Dimming (0-100, dimmers),
+//   Current (A, from the CZone output tables), Settings/Type, ValidTypes,
+//   Group (one card per CZone category), CustomName, ShowUIControl.
+//
+// Pane -> CZone: writes to State / Dimming are passed to this plugin's own
+// Signal K PUT handlers (electrical.czone.<slug>.switch.state / .brightness),
+// so the same safety interlock (Enable NMEA 2000 sending) applies.
+// CZone -> pane: the plugin's Signal K deltas for those paths update State,
+// Status and Dimming, so circuits switched from a display or wall switch
+// follow in the pane.
+//
+// Settings changed in the pane (name, group, type, visibility) are kept in
+// victron-switches.json in the plugin's data directory.
+
+const fs = require('fs')
+const path = require('path')
+const { createVeService } = require('./vedbus')
+
+// The card a circuit goes in when it has several sub-categories: the first of
+// them in this order (a fridge that is also "Power" belongs with Refrigeration).
+const GROUP_PRIORITY = [
+  'Indicators and Alarms', 'Navigation', 'Refrigeration', 'Bilge Pumps', 'Pumps', 'Lighting', 'Fans/Ventilation', 'Climate',
+  'Entertainment', 'Appliances', 'Electronics', 'Communications', 'Engine Management', 'Propulsion Management',
+  'Power', 'Vessel Management', 'Accessories', 'House/Habitat', 'Vessel Critical', '24-Hour Circuits', 'Other'
+]
+const rank = name => { const i = GROUP_PRIORITY.indexOf(name); return i < 0 ? GROUP_PRIORITY.length : i }
+const primaryCategory = names => [...(names || [])].filter(Boolean).sort((a, b) => rank(a) - rank(b))[0] || null
+
+const SERVICE = 'com.victronenergy.switch.czone'
+const SETTINGS_ID = 'czone'
+const TYPE = { momentary: 0, toggle: 1, dimmable: 2 }
+const STATUS_ON = 0x09
+const STATUS_OFF = 0x00
+
+const clip32 = s => {
+  let out = String(s || '')
+  while (Buffer.byteLength(out, 'utf8') > 32) out = out.slice(0, -1)
+  return out
+}
+
+// A channel's /Name. Venus OS lists a switch in Settings > Devices as
+// "/Name: CustomName" (CustomName is the label the pane shows, and keeps each
+// switch in its category card), so /Name is the same for every switch:
+// "CZone: Freezer (13.3 °C)", sorted A-Z by circuit. The circuit name here
+// showed it twice; a module.channel prefix meant nothing to most people.
+const CHANNEL_NAME = 'CZone'
+
+// What follows the name in a switch's label: its temperature, where a
+// temperature input is named after the circuit, and its current while it is on:
+//   "Freezer (-8.2 °C, 2.9 A)"   "Fridge (5.1 °C)"   "Lights (1.9 A)"
+// The GX lists switches alphabetically by this label and has no other order,
+// so the suffix must not move a switch: " (" sorts ahead of any letter or
+// digit, which keeps "Freezer (…)" before "Freezer Temp Control", where plain
+// "Freezer" is. (The earlier "Freezer · 3.0 A" sorted after it, so a switch
+// changed place when it turned on.)
+const TEMP_PART = /^-?\d+(?:\.\d+)?\s*(?:°[CF]|K)$/
+const AMPS_PART = /^\d+(?:\.\d+)?\s*A$/
+// A name typed on the GX comes back with the suffix still on it: take it off.
+// Brackets that are part of a real name ("Pump (aft)") are left alone.
+function stripSuffix (label) {
+  const s = String(label || '').replace(/\s*·\s*[\d.]+\s*A$/, '')
+  const m = /\s*\(([^()]*)\)$/.exec(s)
+  if (!m) return s
+  const parts = m[1].split(',').map(p => p.trim())
+  return parts.every(p => TEMP_PART.test(p) || AMPS_PART.test(p)) ? s.slice(0, m.index) : s
+}
+
+// Kelvin (as on NMEA 2000 and in Signal K) to the GX's temperature unit.
+// compact drops the decimal and the space, for a label that would not fit.
+function temperatureText (kelvin, unit, compact) {
+  const v = unit === 'F' ? (kelvin - 273.15) * 9 / 5 + 32 : unit === 'K' ? kelvin : kelvin - 273.15
+  const sym = unit === 'K' ? 'K' : `°${unit === 'F' ? 'F' : 'C'}`
+  const n = compact ? String(Math.round(v)) : v.toFixed(1)
+  return `${n === '-0' ? '0' : n === '-0.0' ? '0.0' : n}${compact ? '' : ' '}${sym}`
+}
+
+// "celsius" / "fahrenheit" / "kelvin" from the GX's settings -> C, F or K.
+const temperatureUnitFrom = raw => (/^\s*f/i.test(String(raw)) ? 'F' : /^\s*k/i.test(String(raw)) ? 'K' : 'C')
+
+const LABEL_BYTES = 32
+const bytes = s => Buffer.byteLength(s, 'utf8')
+function labelWith (name, kelvin, amps, unit) {
+  let out = name
+  for (const compact of [false, true]) {
+    const parts = []
+    if (typeof kelvin === 'number') parts.push(temperatureText(kelvin, unit, compact))
+    if (typeof amps === 'number') parts.push(`${amps.toFixed(1)} A`)
+    const suffix = parts.length ? ` (${parts.join(', ')})` : ''
+    out = name + suffix
+    if (bytes(out) <= LABEL_BYTES) return out
+    if (compact) { // still too long: the name gives way
+      let n = name
+      while (n.length && bytes(n.trimEnd() + suffix) > LABEL_BYTES) n = n.slice(0, -1)
+      return n.trimEnd() + suffix
+    }
+  }
+  return out
+}
+
+// One card per circuit: the first of its sub-categories (and user-defined
+// categories) in GROUP_PRIORITY order; one with none falls back to DC / AC.
+function groupFor (circuit) {
+  const cats = circuit.categories || {}
+  const subs = [...(cats.sub || circuit.subCategories || []), ...(cats.userDefined || [])]
+  return clip32(circuit.group || primaryCategory(subs) || (cats.master || [])[0] || circuit.masterCategory || 'CZone')
+}
+
+function channelId (circuit) {
+  // D-Bus object path elements: [A-Za-z0-9_]
+  return String(circuit.slug || circuit.name).replace(/[^A-Za-z0-9_]/g, '_') || `c${circuit.zcfCircuitId}`
+}
+
+let instances = 0 // pane services created in this process
+
+function createVictronSwitches (app, { log = () => {}, getCurrent = () => null, getTemperature = () => null, controls = () => null, version = '0', now = () => Date.now() } = {}) {
+  let bus = null
+  let svc = null
+  let unsub = null
+  let currentTimer = null
+  let announceTimers = []
+  let status = { enabled: false, running: false, error: null, channels: 0, deviceInstance: null }
+  let channels = new Map() // slug -> { id, circuit }
+  let store = { outputs: {} }
+  let storeFile = null
+  let showCurrent = true // amps in the switch label while on (gui-v2 does not display /Current yet)
+  let showTemperature = true // and the circuit's temperature, where an input is named after it
+  let temperatureUnit = 'C' // the GX's own setting, read at start and every 30 s
+  let run = 0 // start/stop generation: a start that was overtaken must not carry on
+  const diag = { instance: ++instances, pid: process.pid, startedAt: null, seedRuns: 0, seedAt: null, seedFound: null, seedErrors: 0, lastError: null, owner: null, ownerCheckedAt: null, temperatureUnit: null }
+  const fail = (where, err) => { diag.seedErrors++; diag.lastError = `${where}: ${err && err.message ? err.message : err}` }
+  const recent = [] // last switch-pane requests, for /victron/status
+  const note = entry => { entry.at = new Date().toISOString(); recent.unshift(entry); recent.length = Math.min(recent.length, 10) }
+
+  function loadStore () {
+    try { store = JSON.parse(fs.readFileSync(storeFile, 'utf8')) } catch (_) { store = { outputs: {} } }
+    if (!store.outputs) store.outputs = {}
+  }
+  function saveStore () {
+    try { fs.writeFileSync(storeFile, JSON.stringify(store, null, 2)) } catch (err) { log(`victron-switches.json: ${err.message}`) }
+  }
+  function remember (id, key, value) {
+    store.outputs[id] = { ...(store.outputs[id] || {}), [key]: value }
+    saveStore()
+  }
+
+  // Switch a circuit with the same functions the webapp's ON/OFF and slider
+  // use (direct, synchronous, errors reported). Signal K PUT is the fallback
+  // when the host plugin didn't hand its controls over.
+  function command (kind, slug, value) {
+    const c = controls()
+    if (c && typeof c[kind] === 'function') {
+      const rec = { circuit: slug, [kind]: value, via: 'plugin' }
+      note(rec)
+      try { c[kind](slug, value); rec.result = 'sent'; return true } catch (err) { rec.result = `refused: ${err.message}`; log(`${slug} ${kind}: ${err.message}`); return false }
+    }
+    return put(`electrical.czone.${slug}.switch.${kind === 'state' ? 'state' : 'brightness'}`, value)
+  }
+
+  function put (skPath, value) {
+    const rec = { path: skPath, value, result: 'sent', via: 'signalk-put' }
+    note(rec)
+    if (typeof app.putSelfPath !== 'function') { rec.result = 'app.putSelfPath unavailable'; log(rec.result); return false }
+    try {
+      const r = app.putSelfPath(skPath, value, reply => {
+        rec.reply = reply && { state: reply.state, statusCode: reply.statusCode, message: reply.message }
+        if (reply && reply.statusCode >= 300) log(`PUT ${skPath}=${value}: ${reply.statusCode} ${reply.message || ''}`)
+      })
+      if (r && typeof r.then === 'function') {
+        r.then(reply => { if (reply && !rec.reply) rec.reply = { state: reply.state, statusCode: reply.statusCode, message: reply.message } })
+          .catch(err => { rec.result = `error: ${err.message || err}` })
+      } else if (r && typeof r === 'object' && !rec.reply) {
+        rec.reply = { state: r.state, statusCode: r.statusCode, message: r.message }
+      }
+      return true
+    } catch (err) { rec.result = `error: ${err.message}`; log(`PUT ${skPath}: ${err.message}`); return false }
+  }
+
+  function invokeSettings (msg) {
+    return new Promise((resolve, reject) => bus.invoke({ destination: 'com.victronenergy.settings', ...msg }, (err, res) => err ? reject(new Error(Array.isArray(err) ? err.join(' ') : String(err.message || err))) : resolve(res)))
+  }
+
+  // Reserve a VRM device instance the Venus way (localsettings ClassAndVrmInstance).
+  async function deviceInstance () {
+    const p = `/Settings/Devices/${SETTINGS_ID}/ClassAndVrmInstance`
+    try {
+      await invokeSettings({ path: '/Settings', interface: 'com.victronenergy.Settings', member: 'AddSetting', signature: 'ssvsvv', body: [`Devices/${SETTINGS_ID}`, 'ClassAndVrmInstance', ['s', 'switch:100'], 's', ['i', 0], ['i', 0]] })
+      const v = await invokeSettings({ path: p, interface: 'com.victronenergy.BusItem', member: 'GetValue' })
+      const text = Array.isArray(v) ? v[1] && v[1][0] : v
+      const m = /:(\d+)$/.exec(String(text))
+      return m ? Number(m[1]) : 100
+    } catch (err) {
+      log(`Device instance from localsettings failed (${err.message}); using 100`)
+      return 100
+    }
+  }
+
+  function addChannel (circuit) {
+    const id = channelId(circuit)
+    const base = `/SwitchableOutput/${id}`
+    const dimmer = !!(circuit.capabilities && circuit.capabilities.dimmer)
+    const saved = store.outputs[id] || {}
+    const validTypes = dimmer ? (1 << TYPE.dimmable) | (1 << TYPE.toggle) : (1 << TYPE.toggle) | (1 << TYPE.momentary)
+    const type = Number.isInteger(saved.type) && (validTypes & (1 << saved.type)) ? saved.type : (dimmer ? TYPE.dimmable : TYPE.toggle)
+
+    svc.add(`${base}/Name`, { type: 's', value: CHANNEL_NAME })
+    svc.add(`${base}/State`, {
+      type: 'i',
+      value: 0,
+      text: v => (v ? 'On' : 'Off'),
+      onSet: v => {
+        note({ dbus: `${base}/State`, raw: JSON.stringify(v) })
+        const on = Number(v) ? 1 : 0
+        if (!command('state', circuit.slug, on === 1)) {
+          // Refused (sending off, or a circuit set to confirm before off):
+          // say again what the state is, so the pane's switch goes back.
+          svc.announce([`${base}/State`, `${base}/Status`])
+          return false
+        }
+        svc.set(`${base}/State`, on) // optimistic; CZone feedback confirms
+        commanded(circuit.slug)
+        return true
+      }
+    })
+    svc.add(`${base}/Status`, { type: 'i', value: STATUS_OFF, text: v => (v & 0x01 ? 'On' : 'Off') })
+    if (dimmer) {
+      svc.add(`${base}/Dimming`, {
+        type: 'd',
+        value: null,
+        text: v => (v == null ? '' : `${Math.round(v)}%`),
+        onSet: v => {
+          const pct = Math.max(0, Math.min(100, Number(v)))
+          if (!Number.isFinite(pct) || !command('brightness', circuit.slug, pct / 100)) return false
+          svc.set(`${base}/Dimming`, pct)
+          commanded(circuit.slug)
+          return true
+        }
+      })
+    }
+    svc.add(`${base}/Current`, { type: 'd', value: null, text: v => (v == null ? '' : `${v.toFixed(1)}A`) })
+    svc.add(`${base}/Settings/Type`, {
+      type: 'i',
+      value: type,
+      onSet: v => {
+        const t = Number(v)
+        if (!(validTypes & (1 << t))) return false
+        // Victron's switch API: selecting momentary resets the output. An
+        // output left on would stay on until the next press. The off goes
+        // through the same checks as a tap (sending allowed, confirm before
+        // off); if it is refused, so is the type change.
+        if (t === TYPE.momentary && svc.get(`${base}/State`) === 1) {
+          if (!command('state', circuit.slug, false)) {
+            svc.announce([`${base}/State`, `${base}/Status`, `${base}/Settings/Type`])
+            return false
+          }
+          const from = svc.get(`${base}/Settings/Type`)
+          svc.set(`${base}/State`, 0)
+          svc.set(`${base}/Status`, STATUS_OFF)
+          commanded(circuit.slug)
+          // Until CZone reports the output off, the change is provisional:
+          // with no off within the grace period it is undone (see settleType).
+          const ch = channels.get(circuit.slug)
+          if (ch) ch.typePending = { from }
+        }
+        svc.set(`${base}/Settings/Type`, t); remember(id, 'type', t); return true
+      }
+    })
+    svc.add(`${base}/Settings/ValidTypes`, { type: 'i', value: validTypes })
+    svc.add(`${base}/Settings/Group`, {
+      type: 's',
+      value: saved.Group !== undefined ? saved.Group : groupFor(circuit),
+      onSet: v => { const s = clip32(v); svc.set(`${base}/Settings/Group`, s); remember(id, 'Group', s); return true }
+    })
+    // The label is the user's name (default: circuit name) plus the circuit
+    // current while it is on. A rename from the GUI keeps the name only.
+    svc.add(`${base}/Settings/CustomName`, {
+      type: 's',
+      value: clip32(saved.CustomName || circuit.name),
+      onSet: v => {
+        const name = stripSuffix(String(v || '')).trim() || circuit.name
+        const ch = channels.get(circuit.slug)
+        if (ch) ch.label = name
+        remember(id, 'CustomName', clip32(name))
+        if (ch) refreshLabel(ch); else svc.set(`${base}/Settings/CustomName`, clip32(name))
+        return true
+      }
+    })
+    svc.add(`${base}/Settings/ShowUIControl`, {
+      type: 'i',
+      value: Number.isInteger(saved.ShowUIControl) ? saved.ShowUIControl : 1,
+      onSet: v => { const n = Number(v) | 0; svc.set(`${base}/Settings/ShowUIControl`, n); remember(id, 'ShowUIControl', n); return true }
+    })
+    channels.set(circuit.slug, { id, base, circuit, dimmer, label: saved.CustomName || circuit.name })
+  }
+
+  // Signal K -> pane
+  function onDelta (update) {
+    if (!svc) return
+    if (!update || typeof update.path !== 'string' || !update.path.startsWith('electrical.czone.')) return
+    const m = /^electrical\.czone\.([^.]+)\.switch\.(state|brightness)$/.exec(update.path)
+    if (!m) return
+    const ch = channels.get(m[1])
+    if (!ch) return
+    const v = update.value && typeof update.value === 'object' && 'value' in update.value ? update.value.value : update.value
+    apply(ch, m[2], v)
+  }
+
+  function apply (ch, kind, v) {
+    if (kind === 'state') {
+      const on = v === true || v === 1 || v === 'on' || v === 'ON'
+      svc.set(`${ch.base}/State`, on ? 1 : 0)
+      svc.set(`${ch.base}/Status`, on ? STATUS_ON : STATUS_OFF)
+      if (!on) delete ch.typePending // CZone confirmed the off: momentary stands
+      refreshLabel(ch)
+    } else if (ch.dimmer && typeof v === 'number') {
+      svc.set(`${ch.base}/Dimming`, Math.round(v * 1000) / 10)
+    }
+  }
+
+  // A pane tap shows at once; give CZone a few seconds to confirm before the
+  // pane is put back to what Signal K says.
+  const COMMAND_GRACE_MS = 5000
+  function commanded (slug) {
+    const ch = channels.get(slug)
+    if (ch) ch.commandAt = Date.now()
+  }
+
+  // Bring every switch in line with Signal K. Run at start and then every two
+  // seconds: the plugin only publishes a state when it changes, and the first
+  // CZone status can arrive before this service is listening, so a circuit
+  // that was already on (and stays on) would otherwise never show as on.
+  function seedFromSignalK () {
+    const now = Date.now()
+    const c = controls()
+    const fromPlugin = c && typeof c.getState === 'function' ? c.getState : null
+    const found = { plugin: 0, signalk: 0 }
+    diag.seedRuns++
+    diag.seedAt = new Date(now).toISOString()
+    for (const [slug, ch] of channels) {
+      if (ch.commandAt && now - ch.commandAt < COMMAND_GRACE_MS) continue
+      // One circuit failing must not stop the ones after it.
+      try {
+        // First choice: the state the host plugin decoded from the bus, the
+        // same one the webapp shows. It is there from the first status frame,
+        // whenever this service started listening.
+        const st = fromPlugin ? fromPlugin(slug) : null
+        if (st && (st.state === 'ON' || st.state === 'OFF')) {
+          found.plugin++
+          apply(ch, 'state', st.state === 'ON')
+          if (Number.isFinite(st.percent)) apply(ch, 'brightness', st.percent / 100)
+          continue
+        }
+        if (typeof app.getSelfPath !== 'function') continue
+        for (const kind of ['state', 'brightness']) {
+          const node = app.getSelfPath(`electrical.czone.${slug}.switch.${kind}`)
+          if (node === undefined || node === null) continue
+          if (kind === 'state') found.signalk++
+          onDelta({ path: `electrical.czone.${slug}.switch.${kind}`, value: node })
+        }
+      } catch (err) {
+        fail(`resync ${slug}`, err)
+      } finally {
+        // Here, not after the try: both state readers end with `continue`.
+        settleType(ch)
+      }
+    }
+    diag.seedFound = found
+  }
+
+  // A switch set to momentary while on was sent off. If the grace period has
+  // passed and CZone never reported it off, the output is still on: put the
+  // previous type back rather than leave an on output marked momentary.
+  function settleType (ch) {
+    if (!ch.typePending) return
+    const { from } = ch.typePending
+    delete ch.typePending
+    svc.set(`${ch.base}/Settings/Type`, from)
+    remember(ch.id, 'type', from)
+    const why = `${ch.circuit.name}: CZone did not confirm the off, so momentary was not applied`
+    note({ dbus: `${ch.base}/Settings/Type`, refused: why })
+    log(`Victron switch pane: ${why}`)
+  }
+
+  // What the host plugin has decoded for a circuit (null = nothing yet).
+  function pluginState (slug) {
+    const c = controls()
+    let st = null
+    try { st = c && typeof c.getState === 'function' ? c.getState(slug) : null } catch (_) {}
+    return st && (st.state === 'ON' || st.state === 'OFF') ? (st.state === 'ON' ? 1 : 0) : null
+  }
+
+  // What Signal K says a circuit is, as the pane would apply it (null = no value).
+  function signalkState (slug) {
+    let node
+    try { node = app.getSelfPath(`electrical.czone.${slug}.switch.state`) } catch (_) { return null }
+    if (node === undefined || node === null) return null
+    const v = node && typeof node === 'object' && 'value' in node ? node.value : node
+    return v === true || v === 1 || v === 'on' || v === 'ON' ? 1 : 0
+  }
+
+  // Is this instance still the one the GX talks to? The newest instance takes
+  // the service name when it starts (see vedbus.claim), so finding the name
+  // with another connection means this one has been replaced: it retires
+  // rather than fight for the name.
+  async function checkOwner () {
+    if (!svc) return
+    const mine = run
+    const o = await svc.owner()
+    if (mine !== run || !svc) return
+    diag.owner = o
+    diag.ownerCheckedAt = new Date().toISOString()
+    if (o.owner && o.self && o.owner !== o.self) {
+      log(`Victron switch pane: ${SERVICE} now belongs to ${o.owner}; this instance (${o.self}) stops`)
+      status = { ...status, running: false, error: `replaced by a newer instance (${o.owner})` }
+      stop(true)
+    }
+  }
+
+  // Repeat every switch's state to the GX (see vedbus.announce): shortly after
+  // start, when the GX is still reading the new service, and then regularly.
+  const ANNOUNCE_AFTER_MS = [3000, 10000, 20000]
+  const ANNOUNCE_EVERY_MS = 30000
+  function announceAll () {
+    if (!svc) return
+    const paths = []
+    for (const ch of channels.values()) {
+      paths.push(`${ch.base}/State`, `${ch.base}/Status`, `${ch.base}/Settings/CustomName`)
+      if (ch.dimmer) paths.push(`${ch.base}/Dimming`)
+    }
+    svc.announce(paths)
+  }
+
+  function updateCurrents () {
+    for (const [slug, ch] of channels) {
+      try {
+        const a = getCurrent(`electrical.czone.${slug}.current`)
+        svc.set(`${ch.base}/Current`, typeof a === 'number' ? a : null)
+        refreshLabel(ch)
+      } catch (err) { fail(`current ${slug}`, err) }
+    }
+  }
+
+  // What a label shows is held steady. Every change of a switch's name makes
+  // the GX re-sort its lists and jump to the selected row (seen on the device's
+  // Outputs page on Compass Rose), and a reading that wobbles by 0.1 was
+  // changing the name every few seconds. A shown value is replaced at once
+  // when the reading is a real step away from it, or appears or goes; a
+  // smaller difference replaces it only once the reading has stayed away from
+  // the shown value for a while. /Current itself is always the exact reading.
+  const STEADY = { amps: { step: 0.2, after: 120e3 }, kelvin: { step: 0.5, after: 300e3 } }
+  function steady (ch, key, value) {
+    const shown = ch.shown || (ch.shown = {})
+    const was = shown[key]
+    const take = () => { shown[key] = value; shown[key + 'Since'] = null; return value }
+    if (value === null || was === null || was === undefined) return take()
+    if (Math.round(was * 10) === Math.round(value * 10)) { shown[key + 'Since'] = null; return was }
+    if (Math.abs(value - was) >= STEADY[key].step - 1e-9) return take()
+    const t = now()
+    if (!shown[key + 'Since']) shown[key + 'Since'] = t
+    else if (t - shown[key + 'Since'] >= STEADY[key].after) return take()
+    return was
+  }
+
+  function refreshLabel (ch) {
+    const a = svc.get(`${ch.base}/Current`)
+    const on = svc.get(`${ch.base}/State`) === 1
+    let t = null
+    if (showTemperature) { try { t = getTemperature(ch.circuit.slug) } catch (_) { t = null } }
+    const amps = steady(ch, 'amps', showCurrent && on && typeof a === 'number' && a > 0 ? a : null)
+    const kelvin = steady(ch, 'kelvin', typeof t === 'number' ? t : null)
+    svc.set(`${ch.base}/Settings/CustomName`, labelWith(ch.label, kelvin, amps, temperatureUnit))
+  }
+
+  // The unit the GX shows temperatures in (Settings > Display > Units).
+  async function readTemperatureUnit () {
+    const mine = run
+    try {
+      const v = await invokeSettings({ path: '/Settings/System/Units/Temperature', interface: 'com.victronenergy.BusItem', member: 'GetValue' })
+      if (mine !== run) return
+      const raw = Array.isArray(v) ? (v[1] && v[1][0]) : v
+      diag.temperatureUnit = { setting: raw, used: temperatureUnitFrom(raw) }
+      temperatureUnit = diag.temperatureUnit.used
+    } catch (err) {
+      if (mine !== run) return
+      diag.temperatureUnit = { setting: null, used: 'C', error: err.message }
+      temperatureUnit = 'C'
+    }
+  }
+
+  // mapping: the loaded configuration (lib/zcf), or the path of a ZCF to load.
+  async function start (settings = {}, mapping = null, options = {}) {
+    stop()
+    const mine = ++run
+    // A start overtaken by stop() or a newer start() ends here: stop() has
+    // already closed what this one opened.
+    const overtaken = () => mine !== run
+    status = { enabled: settings.victronSwitches === true, running: false, error: null, channels: 0, deviceInstance: null }
+    showCurrent = settings.victronSwitchCurrent !== false
+    showTemperature = settings.victronSwitchTemperature !== false
+    if (!status.enabled) return status
+    try {
+      const zcfFile = typeof mapping === 'string' ? mapping : null
+      const dataDir = typeof app.getDataDirPath === 'function' ? app.getDataDirPath() : path.dirname(zcfFile || '.')
+      storeFile = path.join(dataDir, 'victron-switches.json')
+      loadStore()
+
+      if (zcfFile) mapping = require('../zcf').load(zcfFile)
+      // The circuits the webapp lists: not those no CZone display shows
+      // (showInCircuitList false) or hidden ones, nor those linked to a
+      // third-party switch: that switch has its own place in the pane, and the
+      // circuit would show it twice.
+      const bridged = new Set((Array.isArray(settings.bridges) ? settings.bridges : []).map(b => b && b.circuit).filter(Boolean))
+      const circuits = ((mapping && mapping.circuits) || []).filter(c => !c.hidden && c.showInCircuitList !== false && !bridged.has(c.name))
+      if (!circuits.length) throw new Error('No circuits in the loaded ZCF')
+
+      if (!options.bus) {
+        let dbus
+        try { dbus = require('dbus-native') } catch (_) { throw new Error('D-Bus support is not installed (only available on a Victron GX)') }
+        bus = dbus.systemBus()
+      } else bus = options.bus
+      // An error on the connection (closed while still connecting, bus restart)
+      // is reported, never thrown: unhandled, it would take Signal K down.
+      if (bus.connection && typeof bus.connection.on === 'function') {
+        bus.connection.on('error', err => { fail('dbus connection', err); log(`Victron switch pane D-Bus: ${err && err.message ? err.message : err}`) })
+      }
+      svc = createVeService({ bus, name: SERVICE, log })
+      const instance = await deviceInstance()
+      if (overtaken()) return status
+      status.deviceInstance = instance
+      await readTemperatureUnit()
+      if (overtaken()) return status
+      const vessel = mapping.vesselName || 'CZone'
+      const root = {
+        '/Mgmt/ProcessName': ['s', 'signalk-czone'],
+        '/Mgmt/ProcessVersion': ['s', version],
+        '/Mgmt/Connection': ['s', 'Signal K plugin'],
+        '/DeviceInstance': ['i', instance],
+        '/ProductId': ['i', 0xFFFF],
+        '/ProductName': ['s', 'CZone Circuits'],
+        '/FirmwareVersion': ['s', version],
+        '/HardwareVersion': ['s', 'Signal K'],
+        '/Serial': ['s', `czone-${SETTINGS_ID}`],
+        '/Connected': ['i', 1],
+        '/State': ['i', 0x100]
+      }
+      for (const [p, [type, value]] of Object.entries(root)) svc.add(p, { type, value })
+      // The device's name in the GX device list. Defaults to the vessel name in
+      // the ZCF; a name typed on the GX is kept (victron-switches.json) and
+      // survives restarts and new ZCF uploads. Cleared = back to the default.
+      const defaultName = clip32(`CZone ${vessel}`)
+      svc.add('/CustomName', {
+        type: 's',
+        value: clip32(store.deviceName || defaultName),
+        onSet: v => {
+          const name = clip32(String(v == null ? '' : v).trim())
+          if (name) store.deviceName = name; else delete store.deviceName
+          saveStore()
+          svc.set('/CustomName', name || defaultName)
+          note({ device: 'CustomName', value: name || defaultName })
+          return true
+        }
+      })
+      for (const c of circuits) addChannel(c)
+      // Listen before the (slow) D-Bus registration, so no change is missed.
+      const sb = app.streambundle && typeof app.streambundle.getSelfBus === 'function' ? app.streambundle.getSelfBus() : null
+      if (sb && typeof sb.onValue === 'function') unsub = sb.onValue(onDelta)
+      seedFromSignalK()
+      updateCurrents()
+      await svc.start()
+      if (overtaken()) return status
+      diag.startedAt = new Date().toISOString()
+      seedFromSignalK()
+      currentTimer = setInterval(() => { seedFromSignalK(); updateCurrents() }, 2000)
+      announceTimers = ANNOUNCE_AFTER_MS.map(ms => setTimeout(announceAll, ms))
+      announceTimers.push(setInterval(announceAll, ANNOUNCE_EVERY_MS))
+      announceTimers.push(setTimeout(checkOwner, 5000), setInterval(checkOwner, ANNOUNCE_EVERY_MS), setInterval(readTemperatureUnit, ANNOUNCE_EVERY_MS))
+      status = { ...status, running: true, channels: channels.size }
+      log(`Victron switch pane: ${channels.size} circuits on ${SERVICE} (device instance ${instance})`)
+    } catch (err) {
+      if (overtaken()) return status
+      status = { ...status, running: false, error: err.message }
+      log(`Victron switch pane failed: ${err.message}`)
+      stop(true)
+    }
+    return status
+  }
+
+  function stop (keepStatus) {
+    run++
+    if (typeof unsub === 'function') { try { unsub() } catch (_) {} }
+    unsub = null
+    clearInterval(currentTimer)
+    currentTimer = null
+    for (const t of announceTimers) { clearTimeout(t); clearInterval(t) }
+    announceTimers = []
+    if (svc) svc.stop()
+    svc = null
+    if (bus && typeof bus.connection === 'object' && bus.connection && typeof bus.connection.end === 'function') {
+      try { bus.connection.end() } catch (_) {}
+    }
+    bus = null
+    channels = new Map()
+    if (!keepStatus) status = { ...status, running: false }
+  }
+
+  // Everything needed to tell, from one page, why the pane and a circuit
+  // disagree: is this the instance the GX talks to, is the resync running, and
+  // which circuits differ between Signal K and what the pane has been given.
+  function report () {
+    const on = []
+    const mismatch = []
+    if (svc) {
+      for (const [slug, ch] of channels) {
+        const pane = svc.get(`${ch.base}/State`)
+        const plugin = pluginState(slug)
+        const sk = signalkState(slug)
+        if (pane === 1) on.push(slug)
+        if ((plugin !== null && plugin !== pane) || (sk !== null && sk !== pane)) mismatch.push({ circuit: slug, plugin, signalk: sk, pane })
+      }
+    }
+    let signalkValues = 0
+    for (const slug of channels.keys()) if (signalkState(slug) !== null) signalkValues++
+    return { ...status, on, mismatch, diag: { ...diag, signalkValues, liveChannels: channels.size, ownsName: diag.owner ? diag.owner.owner === diag.owner.self : null }, recent }
+  }
+
+  return { start, stop, status: report, _checkOwner: checkOwner, _onDelta: onDelta, _service: () => svc, _resync: () => { seedFromSignalK(); updateCurrents() }, _announce: announceAll }
+}
+
+module.exports = { createVictronSwitches, SERVICE, groupFor, channelId, GROUP_PRIORITY, labelWith, CHANNEL_NAME, stripSuffix, temperatureText, temperatureUnitFrom }

package/lib/victron/vedbus.js

@@ -0,0 +1,182 @@
+'use strict'
+
+// Minimal Victron "VeDbus" service on dbus-native, modelled on velib_python's
+// vedbus.py, which every Venus OS driver uses:
+//
+//   - one D-Bus service name (e.g. com.victronenergy.switch.czone)
+//   - every value is an object path implementing com.victronenergy.BusItem
+//     (GetValue / SetValue / GetText), and emits PropertiesChanged(a{sv})
+//   - the root "/" also implements GetItems (all paths) and GetValue (dict),
+//     and emits ItemsChanged(a{sa{sv}}) for batched updates (used by gui-v2)
+//
+// Values are dbus-native variants: ['i', 1], ['d', 1.5], ['s', 'x'].
+// An invalid value is the empty int array ['ai', []], as in vedbus.py.
+
+const IFACE = 'com.victronenergy.BusItem'
+
+const BUSITEM = {
+  name: IFACE,
+  methods: {
+    GetValue: ['', 'v', [], ['value']],
+    SetValue: ['v', 'i', ['value'], ['result']],
+    GetText: ['', 's', [], ['text']]
+  },
+  signals: { PropertiesChanged: ['a{sv}', ['changes']] }
+}
+
+const ROOT = {
+  name: IFACE,
+  methods: {
+    GetItems: ['', 'a{sa{sv}}', [], ['items']],
+    GetValue: ['', 'v', [], ['value']],
+    SetValue: ['v', 'i', ['value'], ['result']],
+    GetText: ['', 's', [], ['text']]
+  },
+  signals: { ItemsChanged: ['a{sa{sv}}', ['changes']] }
+}
+
+const INVALID = ['ai', []]
+
+function variant (type, value) {
+  if (value === null || value === undefined) return INVALID
+  if (type === 'i') return Number.isFinite(value) ? ['i', Math.round(value)] : INVALID
+  if (type === 'd') return Number.isFinite(value) ? ['d', value] : INVALID
+  if (type === 's') return ['s', String(value)]
+  if (type === 'ai') return ['ai', value.map(v => Math.round(v))]
+  return INVALID
+}
+
+// dbus-native hands a received variant over as [[signature], [value]].
+function unwrapVariant (v) {
+  if (Array.isArray(v) && v.length === 2 && Array.isArray(v[1])) {
+    const sig = v[0] && v[0][0] && v[0][0].type
+    if (sig === 'a') return v[1][0] // array value (e.g. LightControls)
+    return v[1][0]
+  }
+  return v
+}
+
+// items: { '/Path': { type: 'i'|'d'|'s'|'ai', value, text?, onSet?(value) -> boolean } }
+function createVeService ({ bus, name, log = () => {} }) {
+  const items = new Map()
+  let started = false
+  let pending = new Map() // batched ItemsChanged
+  let flushTimer = null
+
+  const textOf = (path, it) => (typeof it.text === 'function' ? it.text(it.value) : it.text) ?? (it.value == null ? '' : String(it.value))
+  const entry = (path, it) => [path, [['Value', variant(it.type, it.value)], ['Text', ['s', textOf(path, it)]]]]
+
+  function exportPath (path, it) {
+    const obj = {
+      GetValue: () => variant(it.type, it.value),
+      GetText: () => textOf(path, it),
+      SetValue: v => {
+        const value = unwrapVariant(v)
+        if (typeof it.onSet !== 'function') return 1
+        try { return it.onSet(value) === false ? 1 : 0 } catch (err) { log(`SetValue ${path}: ${err.message}`); return 1 }
+      }
+    }
+    bus.exportInterface(obj, path, BUSITEM)
+  }
+
+  function exportRoot () {
+    bus.exportInterface({
+      GetItems: () => [...items].map(([p, it]) => entry(p, it)),
+      GetValue: () => ['a{sv}', [...items].map(([p, it]) => [p.slice(1), variant(it.type, it.value)])],
+      GetText: () => '',
+      SetValue: () => 1
+    }, '/', ROOT)
+  }
+
+  function flush () {
+    flushTimer = null
+    if (!pending.size) return
+    const changes = [...pending].map(([p, it]) => entry(p, it))
+    pending = new Map()
+    try { bus.sendSignal('/', IFACE, 'ItemsChanged', 'a{sa{sv}}', [changes]) } catch (err) { log(`ItemsChanged: ${err.message}`) }
+  }
+
+  function add (path, def) {
+    const it = { ...def }
+    items.set(path, it)
+    if (started) { exportPath(path, it); pending.set(path, it); scheduleFlush() }
+    return it
+  }
+
+  function scheduleFlush () {
+    if (!flushTimer) flushTimer = setTimeout(flush, 50)
+  }
+
+  // Update a value; emits PropertiesChanged on the path and a batched
+  // ItemsChanged on the root. No-op if unchanged.
+  function set (path, value) {
+    const it = items.get(path)
+    if (!it) return
+    const same = Array.isArray(value) ? JSON.stringify(value) === JSON.stringify(it.value) : it.value === value
+    if (same) return
+    it.value = value
+    if (!started) return
+    try {
+      bus.sendSignal(path, IFACE, 'PropertiesChanged', 'a{sv}', [[['Value', variant(it.type, it.value)], ['Text', ['s', textOf(path, it)]]]])
+    } catch (err) { log(`PropertiesChanged ${path}: ${err.message}`) }
+    pending.set(path, it)
+    scheduleFlush()
+  }
+
+  // Send the current values again, changed or not, in one ItemsChanged.
+  // A listener that took its snapshot of a newly registered service just as a
+  // value changed can be left holding the old value; since `set` only signals
+  // changes, nothing would ever correct it.
+  function announce (paths) {
+    if (!started) return
+    for (const p of paths) {
+      const it = items.get(p)
+      if (it) pending.set(p, it)
+    }
+    if (pending.size) scheduleFlush()
+  }
+
+  function get (path) { const it = items.get(path); return it ? it.value : undefined }
+
+  // ALLOW_REPLACEMENT | REPLACE_EXISTING | DO_NOT_QUEUE: the newest instance
+  // always gets the name. An older one that was never shut down properly
+  // (plugin restarted, or an earlier Signal K process still alive) would
+  // otherwise keep answering the GX with values that no longer change.
+  const NAME_FLAGS = 0x1 | 0x2 | 0x4
+  function claim () {
+    return new Promise((resolve, reject) => {
+      bus.requestName(name, NAME_FLAGS, (err, code) => {
+        if (err) return reject(new Error(`requestName ${name}: ${err.message || err}`))
+        if (code !== 1 && code !== 4) return reject(new Error(`requestName ${name}: code ${code} (name in use?)`))
+        resolve()
+      })
+    })
+  }
+
+  function start () {
+    exportRoot()
+    for (const [p, it] of items) exportPath(p, it)
+    started = true
+    return claim()
+  }
+
+  // Who the bus says owns the service name, and this connection's own name.
+  function owner () {
+    return new Promise(resolve => {
+      const done = (err, who) => resolve({ owner: err ? null : who, self: bus.name || null, error: err ? String((err && err.message) || err) : null })
+      try {
+        bus.invoke({ destination: 'org.freedesktop.DBus', path: '/org/freedesktop/DBus', interface: 'org.freedesktop.DBus', member: 'GetNameOwner', signature: 's', body: [name] }, done)
+      } catch (err) { done(err) }
+    })
+  }
+
+  function stop () {
+    clearTimeout(flushTimer)
+    started = false
+    try { bus.releaseName && bus.releaseName(name, () => {}) } catch (_) {}
+  }
+
+  return { add, set, get, announce, start, stop, claim, owner, items }
+}
+
+module.exports = { createVeService, variant, unwrapVariant, INVALID }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-czone",
-  "version": "0.3.0-beta.15",
+  "version": "0.3.0-beta.17",
   "description": "BETA: Signal K CZone monitoring and control using dynamically parsed ZCF configuration and NMEA 2000",
   "main": "index.js",
   "keywords": [
@@ -42,7 +42,7 @@
     "icon.png"
   ],
   "scripts": {
-    "test": "node test/zcf.test.js && node test/zcf-fixtures.test.js && node test/circuit-state.test.js && node test/czone.test.js && node test/nmea2000.test.js && node test/control-x-plus.test.js && node test/signalk.test.js && node test/write.test.js && node test/circuit-status.test.js && node test/status-mapping-regression.test.js && node test/state.test.js && node test/config-network.test.js && node test/config-namespace.test.js && node test/monitoring.test.js && node test/confirm-off.test.js && node test/webapp-current.test.js && node test/bridge.test.js && node test/trends.test.js && node test/inputs.test.js && node --require ./test/helpers/gx-low-space.cjs test/trends.test.js"
+    "test": "node test/zcf.test.js && node test/zcf-fixtures.test.js && node test/circuit-state.test.js && node test/czone.test.js && node test/nmea2000.test.js && node test/control-x-plus.test.js && node test/signalk.test.js && node test/write.test.js && node test/circuit-status.test.js && node test/status-mapping-regression.test.js && node test/state.test.js && node test/config-network.test.js && node test/config-namespace.test.js && node test/monitoring.test.js && node test/confirm-off.test.js && node test/webapp-current.test.js && node test/webapp-auth.test.js && node test/bridge.test.js && node test/victron-switches.test.js && node test/victron-label-steady.test.js && node test/switch-pane-plugin.test.js && node test/trends.test.js && node test/inputs.test.js && node --require ./test/helpers/gx-low-space.cjs test/trends.test.js"
   },
   "dependencies": {
     "signalk-czone-zcf": "0.1.0-beta.2"

package/public/index.html

@@ -353,7 +353,7 @@
       <div class="connection" id="connection"><i></i><span>Connecting to Signal K…</span></div>
       <section class="hero">
         <h1 id="heroTitle">Your Boat, Your Circuits</h1>
-        <p>Monitor and control your boat's electrical systems.</p><div id="writeGate" style="display:none;margin-top:12px;padding:10px 12px;border:1px solid rgba(255,195,77,.35);border-radius:10px;background:rgba(255,195,77,.08);color:#ffd98a;font-size:12px;line-height:1.5"></div>
+        <p>Monitor and control your boat's electrical systems.</p><div id="loadError" role="alert" hidden style="position:relative;z-index:1;margin-top:12px;padding:12px;border:1px solid var(--amber);border-radius:10px;background:var(--panel);line-height:1.5"></div><div id="writeGate" style="display:none;margin-top:12px;padding:10px 12px;border:1px solid rgba(255,195,77,.35);border-radius:10px;background:rgba(255,195,77,.08);color:#ffd98a;font-size:12px;line-height:1.5"></div>
       </section>
       <section class="section trend-panel" id="trendPanel">
         <div class="section-head"><span>📈</span><div><h2 id="trendTitle"></h2><span class="subtle" id="trendSub"></span></div><button type="button" class="sort trend-close" onclick="closeTrend()" aria-label="Close trend">✕ Close</button></div>
@@ -700,10 +700,45 @@
     if (Array.isArray(data.modes)) modes = data.modes;
     if (data.activeMode) activeMode = data.activeMode;
   }
+  function showLoadError(message, signIn) {
+    const el = document.querySelector('#loadError');
+    el.textContent = message + ' ';
+    const link = document.createElement('a');
+    link.style.color = 'var(--cyan)';
+    if (signIn) {
+      const here = window.location.pathname + window.location.search + window.location.hash;
+      link.href = '/admin/#/login?redirect=' + encodeURIComponent(here);
+      link.textContent = 'Sign in';
+    } else {
+      link.href = window.location.href;
+      link.textContent = 'Retry';
+      link.onclick = event => { event.preventDefault(); window.location.reload(); };
+    }
+    el.appendChild(link);
+    el.hidden = false;
+  }
+
+  async function showCircuitRequestError(response) {
+    let signIn = response.status === 401;
+    if (response.status === 403) {
+      try {
+        const r = await fetch('/skServer/loginStatus', { cache:'no-store', credentials:'include' });
+        if (r.ok) signIn = (await r.json()).status === 'notLoggedIn';
+      } catch (_) { /* Keep the permission error if login status cannot be checked. */ }
+    }
+    const message = signIn
+      ? 'Sign in to Signal K to load CZone circuits.'
+      : response.status === 403
+        ? 'Signal K denied access to CZone circuits. Your account may not have the required permissions.'
+        : 'Could not load CZone circuits (HTTP ' + response.status + '). Check the Signal K server and CZone plugin.';
+    showLoadError(message, signIn);
+    updateSocketIndicator(signIn ? 'Sign in required' : 'Unable to load CZone circuits', false);
+  }
+
   async function refreshOnce(reason = 'manual') {
     try {
       const r = await fetch(`${API}/circuits`, { cache:'no-store', credentials:'include' });
-      if (!r.ok) throw new Error('Signal K plugin unavailable (HTTP ' + r.status + ')');
+      if (!r.ok) { await showCircuitRequestError(r); return false; }
       const data = await r.json();
       const incoming = Array.isArray(data.circuits) ? data.circuits : [];
       console.debug('[CZone UI] REST refresh', reason, { circuits: incoming.length, modes: Array.isArray(data.modes) ? data.modes.length : 0, sendingEnabled: data.sendingEnabled === true, nmeaReady: data.nmeaReady === true });
@@ -719,12 +754,14 @@
         : socketEverOpen
           ? `<i></i><span>Live updates lost · reconnecting… (circuits as of ${new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })})</span>`
           : '<i></i><span>Circuits loaded · connecting live updates…</span>';
+      document.querySelector('#loadError').hidden = true;
       render();
       return true;
     } catch (e) {
       console.warn('[CZone UI] REST refresh failed', reason, e);
       document.querySelector('#connection').classList.remove('ok');
-      document.querySelector('#connection').innerHTML = '<i></i><span>Waiting for Signal K…</span>';
+      showLoadError('Could not load CZone circuits. Check the Signal K connection and CZone plugin. ' + e.message, false);
+      updateSocketIndicator('Unable to load CZone circuits', false);
       return false;
     }
   }
@@ -1334,7 +1371,8 @@
   }
 
   refreshVesselName();
-  refreshOnce('initial-load').then(() => {
+  refreshOnce('initial-load').then(loaded => {
+    if (!loaded) return;
     if (circuits.length) {
       connectSocket();
       sendSubscriptions();

package/public/remoteEntry.js

@@ -31,6 +31,7 @@ var signalk_czone = (function () {
     var uploadState = React.useState(null)
     var uploadFile = uploadState[0]
     var setUploadFile = uploadState[1]
+    var paneState = React.useState(null); var pane = paneState[0]; var setPane = paneState[1]
     var trendState = React.useState(null)
     var trend = trendState[0]
     var setTrend = trendState[1]
@@ -111,11 +112,26 @@ var signalk_czone = (function () {
         .catch(function () {})
     }
 
+    function loadPaneStatus () {
+      return fetch('/plugins/signalk-czone/victron/status', { credentials: 'same-origin', cache: 'no-store' })
+        .then(function (r) { return r.ok ? r.json() : null })
+        .then(function (value) { setPane(value) })
+        .catch(function () {})
+    }
+
+    function paneSummary () {
+      if (configuration.victronSwitches !== true) return 'Switched off.'
+      if (!pane) return 'Checking…'
+      if (pane.running) return pane.channels + ' circuits in the switch pane (device instance ' + pane.deviceInstance + ').'
+      return pane.error ? 'Not running: ' + pane.error : 'Starting…'
+    }
+
     React.useEffect(function () {
       loadConfiguration().catch(function (err) { setError(err.message || String(err)) })
       loadTrendStatus()
+      loadPaneStatus()
       // Saving a trend setting restarts the plugin; show where trends go now.
-      var timer = setInterval(loadTrendStatus, 5000)
+      var timer = setInterval(function () { loadTrendStatus(); loadPaneStatus() }, 5000)
       return function () { clearInterval(timer) }
     }, [])
 
@@ -447,6 +463,24 @@ var signalk_czone = (function () {
         )
       ),
 
+      React.createElement('div', { style: { marginBottom: 14, padding: 12, border: '1px solid #ccc', borderRadius: 6 } },
+        React.createElement('strong', null, 'Victron switch pane'),
+        React.createElement('div', { style: { marginTop: 6, fontSize: 12 } }, 'Victron GX only (Venus OS 3.60 or later). The CZone circuits as switches on the GX touch screen, Remote Console and VRM, one card per CZone category. Switching there needs CZone read/write control enabled; circuits set to confirm before turning off (on) are not turned off (on) from there unless other apps are allowed to.'),
+        React.createElement('div', { style: { marginTop: 9 } },
+          React.createElement('label', null,
+            React.createElement('input', { type: 'checkbox', checked: configuration.victronSwitches === true, disabled: busy, onChange: function (e) { persist({ victronSwitches: e.target.checked }) } }),
+            ' Show CZone circuits in the Victron switch pane'
+          )
+        ),
+        React.createElement('div', { style: { marginTop: 6 } },
+          React.createElement('label', null,
+            React.createElement('input', { type: 'checkbox', checked: configuration.victronSwitchCurrent !== false, disabled: busy || configuration.victronSwitches !== true, onChange: function (e) { persist({ victronSwitchCurrent: e.target.checked }) } }),
+            ' Show circuit current in the label while on'
+          )
+        ),
+        React.createElement('div', { style: { marginTop: 6, fontSize: 12 } }, paneSummary())
+      ),
+
       React.createElement('div', { style: { marginBottom: 14, padding: 12, border: '1px solid #ccc', borderRadius: 6 } },
         React.createElement('strong', null, 'Trends'),
         React.createElement('div', { style: { marginTop: 6, fontSize: 12 } }, 'Off by default. Stores each circuit\'s current every 10 seconds as plain CSV files, for the trend charts in the webapp (the arrow at the end of a circuit row). Not needed if the data already goes to a database such as InfluxDB.'),