signalk-automation-plugin 0.0.1 → 0.0.3

package/lib/runtime.js

@@ -31,6 +31,7 @@ class Runtime {
     this.pendingSince = {}
     this.lastDebounce = {}
     this.lastCronMinute = ''
+    this.lastQuantized = {}
     this.unsubscribes = []
   }
 
@@ -52,10 +53,11 @@ class Runtime {
   }
 
   isEnabled (auto) {
-    if (Object.prototype.hasOwnProperty.call(this.state.enabled, auto.id)) {
-      return !!this.state.enabled[auto.id]
-    }
-    return auto.enabled !== false
+    return !!this.state.enabled[auto.id]
+  }
+
+  isVerbose (auto) {
+    return !!this.state.verbose[auto.id]
   }
 
   setEnabled (id, enabled) {
@@ -63,19 +65,43 @@ class Runtime {
     store.saveState(this.dataDir, this.state)
   }
 
-  setHelper (id, value) {
+  setVerbose (id, verbose) {
+    this.state.verbose[id] = !!verbose
+    store.saveState(this.dataDir, this.state)
+  }
+
+  async setHelper (id, value, opts) {
     const def = this.doc.helpers[id]
     if (!def) throw new Error('Unknown helper: ' + id)
+    const previous = Object.prototype.hasOwnProperty.call(this.helperValues, id)
+      ? this.helperValues[id]
+      : undefined
     const coerced = helpers.coerce(def, value)
     this.helperValues[id] = coerced
     this.values[helpers.helperPath(id)] = coerced
     this.persistHelpers()
+    const changed = !engine.sameValue(previous, coerced)
+    if (changed) {
+      this.recordSwitch({
+        kind: 'helper',
+        path: id,
+        from: previous,
+        to: coerced,
+        changed: true
+      })
+      if (!opts || opts.kick !== false) {
+        await this.kickPath(helpers.helperPath(id), coerced)
+      }
+    }
     return coerced
   }
 
-  resetHelper (id) {
+  async resetHelper (id) {
     const def = this.doc.helpers[id]
     if (!def) throw new Error('Unknown helper: ' + id)
+    const previous = Object.prototype.hasOwnProperty.call(this.helperValues, id)
+      ? this.helperValues[id]
+      : undefined
     if (def.default === undefined) {
       delete this.helperValues[id]
       delete this.values[helpers.helperPath(id)]
@@ -84,9 +110,23 @@ class Runtime {
       this.values[helpers.helperPath(id)] = this.helperValues[id]
     }
     this.persistHelpers()
+    const next = Object.prototype.hasOwnProperty.call(this.helperValues, id)
+      ? this.helperValues[id]
+      : undefined
+    if (!engine.sameValue(previous, next)) {
+      await this.kickPath(helpers.helperPath(id), next)
+    }
     return this.helperValues[id]
   }
 
+  async kickPath (p, value) {
+    for (const auto of this.doc.automations) {
+      if (!engine.triggerMatchesPath(auto, p)) continue
+      if (engine.quantizedUnchanged(this.lastQuantized, auto, p, value)) continue
+      await this.maybeRun(auto, { path: p, value })
+    }
+  }
+
   setPathValue (p, value, meta) {
     this.values[p] = value
     if (meta && meta.$source) {
@@ -96,19 +136,16 @@ class Runtime {
 
   async handlePathChange (p, value, source) {
     this.setPathValue(p, value, { $source: source })
-    this.applyLatches(p, source)
-    for (const auto of this.doc.automations) {
-      if (!engine.triggerMatchesPath(auto, p)) continue
-      await this.maybeRun(auto, { path: p, value })
-    }
+    await this.applyLatches(p, source)
+    await this.kickPath(p, value)
   }
 
-  applyLatches (p, source) {
+  async applyLatches (p, source) {
     const fromSelf = source && String(source).includes(this.pluginId)
     if (fromSelf) return
     for (const def of Object.values(this.doc.helpers)) {
       if (def.latch_on_external_put === p && def.type === 'boolean') {
-        if (this.values[p]) this.setHelper(def.id, true)
+        if (this.values[p]) await this.setHelper(def.id, true)
       }
     }
   }
@@ -129,8 +166,8 @@ class Runtime {
   async maybeRun (auto, trigger) {
     if (!this.isEnabled(auto)) return
     const ctx = this.makeCtx(trigger)
-    const trig = await engine.evalList(auto.trigger || [], ctx)
-    const matched = !(auto.trigger || []).length || trig.pass
+    const trig = await engine.evalListAll(auto.trigger || [], ctx)
+    const matched = engine.triggerListMatched(auto.trigger, trig.results)
 
     if (!matched) {
       this.lastTruthy[auto.id] = false
@@ -145,7 +182,7 @@ class Runtime {
     }
 
     const prev = !!this.lastTruthy[auto.id]
-    const edge = auto.edge || 'rising'
+    const edge = auto.edge || 'every'
     if (edge === 'rising' && prev) return
     if (edge === 'falling') return
     this.lastTruthy[auto.id] = true
@@ -156,26 +193,135 @@ class Runtime {
 
     this.lastDebounce[auto.id] = this.now()
     const record = await engine.evaluateAutomation(auto, this.makeCtx(trigger))
+    this.finishRun(auto, record, { forceTrace: false })
+    return record
+  }
+
+  keepTrace (auto, record, extra) {
+    extra = extra || {}
+    if (extra.forceTrace) return true
+    if (this.isVerbose(auto)) return true
+    if (record.result === 'failure') return true
+    if (record.result === 'ok') {
+      return (record.actions || []).some((a) => a.changed)
+    }
+    return false
+  }
+
+  finishRun (auto, record, extra) {
+    extra = extra || {}
     this.state.lastRun[auto.id] = {
       ts: record.ts,
       result: record.result,
       reason: record.reason || null
     }
     store.saveState(this.dataDir, this.state)
-    store.appendTrace(this.dataDir, auto.id, record, this.traceCount)
+    if (this.keepTrace(auto, record, extra)) {
+      store.appendTrace(this.dataDir, auto.id, record, this.traceCount)
+    }
+    this.noteSwitches(auto, record)
+    if (this.isVerbose(auto) && record.verboseLog) this.info(record.verboseLog)
+  }
+
+  scheduleOnly (auto) {
+    const trig = auto.trigger || []
+    return trig.length > 0 && trig.every((t) => t.schedule)
+  }
+
+  async evaluateOnStart () {
+    this.seedFromSelf()
+    for (const auto of this.doc.automations) {
+      if (!this.isEnabled(auto)) continue
+      if (this.scheduleOnly(auto)) continue
+      await this.maybeRun(auto, { start: true })
+    }
+  }
+
+  seedFromSelf () {
+    if (!this.app || typeof this.app.getSelfPath !== 'function') return
+    for (const p of engine.collectPaths(this.doc)) {
+      if (p.startsWith('automations.helpers.')) continue
+      try {
+        const raw = this.app.getSelfPath(p)
+        const value =
+          raw && typeof raw === 'object' && Object.prototype.hasOwnProperty.call(raw, 'value')
+            ? raw.value
+            : raw
+        if (value !== undefined) this.values[p] = value
+      } catch (_) {}
+    }
+  }
+
+  async runNow (id) {
+    const auto = this.doc.automations.find((a) => a.id === id)
+    if (!auto) throw new Error('Unknown automation: ' + id)
+    this.seedFromSelf()
+    const forced = Object.assign({}, auto, { trigger: [] })
+    const record = await engine.evaluateAutomation(
+      forced,
+      this.makeCtx({ manual: true }, { skipDelay: true, skipUnchanged: false })
+    )
+    record.id = auto.id
+    record.manual = true
+    this.finishRun(auto, record, { forceTrace: true })
+    if (!this.isVerbose(auto)) {
+      this.info('Run ' + (auto.alias || auto.id) + ' → ' + record.result + (record.reason ? ' (' + record.reason + ')' : ''))
+    }
     return record
   }
 
-  makeCtx (trigger) {
+  info (msg) {
+    if (this.log && typeof this.log.info === 'function') this.log.info(msg)
+    else if (this.log && typeof this.log.debug === 'function') this.log.debug(msg)
+  }
+
+  formatSwitch (row) {
+    const who = [row.automation, row.branch].filter(Boolean).join(' / ')
+    const kind = row.kind === 'helper' ? 'helper ' + row.path : 'PUT ' + row.path
+    const line = (who ? who + ' · ' : '') + kind + '  ' + fmtVal(row.from) + ' → ' + fmtVal(row.to)
+    return row.changed === false ? line + ' (unchanged)' : line
+  }
+
+  recordSwitch (entry) {
+    const row = Object.assign({ ts: new Date(this.now()).toISOString() }, entry)
+    if (row.changed === false) {
+      if (this.log && typeof this.log.debug === 'function') this.log.debug(this.formatSwitch(row))
+      return row
+    }
+    store.appendSwitchLog(this.dataDir, row, 50)
+    this.info(this.formatSwitch(row))
+    return row
+  }
+
+  noteSwitches (auto, record) {
+    for (const a of record.actions || []) {
+      if (a.type !== 'put' || !a.ok) continue
+      this.recordSwitch({
+        kind: 'put',
+        automation: auto.alias || auto.id,
+        id: auto.id,
+        branch: record.choose || null,
+        path: a.path,
+        from: a.previous,
+        to: a.value,
+        changed: a.changed !== false
+      })
+    }
+  }
+
+  makeCtx (trigger, extra) {
+    extra = extra || {}
     return {
       values: this.values,
       zones: this.doc.zones,
       enabled: true,
       trigger,
       now: this.now(),
+      skipDelay: !!extra.skipDelay,
+      skipUnchanged: extra.skipUnchanged !== false,
       put: (p, value) => this.put(p, value),
       notify: (p, state, message) => this.notify(p, state, message),
-      setHelper: (id, value) => this.setHelper(id, value),
+      setHelper: (id, value) => this.setHelper(id, value, { kick: false }),
       sleep: this.sleep,
       runScript: engine.makeRunScript({
         scriptsDir: this.scriptsDir,
@@ -185,8 +331,8 @@ class Runtime {
   }
 
   async put (p, value) {
+    if (this.putFn) await this.putFn(p, value)
     this.values[p] = value
-    if (this.putFn) return this.putFn(p, value)
   }
 
   async notify (p, state, message) {
@@ -208,6 +354,7 @@ class Runtime {
         on_start: def.on_start,
         default: def.default,
         options: def.options,
+        yaml: yaml.snippetHelper(this.doc, def.id),
         value: Object.prototype.hasOwnProperty.call(this.helperValues, def.id)
           ? this.helperValues[def.id]
           : null,
@@ -217,10 +364,20 @@ class Runtime {
         id: auto.id,
         alias: auto.alias,
         enabled: this.isEnabled(auto),
-        yamlEnabled: auto.enabled !== false,
+        verbose: this.isVerbose(auto),
+        yaml: yaml.snippetAutomation(this.doc, auto.id),
         lastRun: this.state.lastRun[auto.id] || null
       })),
-      zones: Object.values(this.doc.zones),
+      zones: Object.values(this.doc.zones).map((z) => ({
+        id: z.id,
+        name: z.name,
+        lat: z.lat,
+        lon: z.lon,
+        radius: z.radius,
+        yaml: yaml.snippetHelper(this.doc, z.id)
+      })),
+      switches: store.loadSwitchLog(this.dataDir),
+      headSha: git.currentSha(this.automationsDir),
       commits: git.isGitRepo(this.automationsDir)
         ? git.listCommits(this.automationsDir, 40)
         : []
@@ -231,11 +388,39 @@ class Runtime {
     return store.loadTraces(this.dataDir, id)
   }
 
+  diffCommit (sha) {
+    const to = sha || ''
+    if (!to) throw new Error('Commit sha is required')
+    const from = this.state.activeSha || git.currentSha(this.automationsDir)
+    const result = git.diffRange(this.automationsDir, from, to)
+    const commits = git.listCommits(this.automationsDir, 80)
+    const found = commits.find((c) => c.sha === result.to) || {}
+    return {
+      from: result.from,
+      to: result.to,
+      diff: result.diff,
+      subject: found.subject || '',
+      current: !result.from || result.from === result.to
+    }
+  }
+
   activateCommit (sha) {
     const dest = store.liveDir(this.dataDir)
     const incoming = dest + '.incoming'
     if (fs.existsSync(incoming)) fs.rmSync(incoming, { recursive: true, force: true })
     git.materializeCommit(this.automationsDir, sha, incoming)
+    return this.installIncoming(incoming, dest, sha)
+  }
+
+  reloadWorkingTree () {
+    const dest = store.liveDir(this.dataDir)
+    const incoming = dest + '.incoming'
+    if (fs.existsSync(incoming)) fs.rmSync(incoming, { recursive: true, force: true })
+    store.copyYamlFiles(this.automationsDir, incoming)
+    return this.installIncoming(incoming, dest, git.currentSha(this.automationsDir))
+  }
+
+  installIncoming (incoming, dest, sha) {
     const next = yaml.loadYamlDir(incoming)
     if (next.errors.length) {
       fs.rmSync(incoming, { recursive: true, force: true })
@@ -247,7 +432,7 @@ class Runtime {
     if (fs.existsSync(dest)) fs.renameSync(dest, bak)
     fs.renameSync(incoming, dest)
     if (fs.existsSync(bak)) fs.rmSync(bak, { recursive: true, force: true })
-    this.state.activeSha = sha
+    this.state.activeSha = sha || null
     store.saveState(this.dataDir, this.state)
     this.load()
     return this.snapshot()
@@ -267,4 +452,13 @@ function holdMs (auto) {
   return 0
 }
 
+function fmtVal (v) {
+  if (v === undefined) return 'unset'
+  try {
+    return JSON.stringify(v)
+  } catch (_) {
+    return String(v)
+  }
+}
+
 module.exports = { Runtime }

package/lib/store.js

@@ -7,6 +7,7 @@ function emptyState () {
   return {
     helpers: {},
     enabled: {},
+    verbose: {},
     activeSha: null,
     lastRun: {}
   }
@@ -60,6 +61,43 @@ function liveDir (dir) {
   return path.join(dir, 'live')
 }
 
+function copyYamlFiles (fromDir, toDir) {
+  fs.mkdirSync(toDir, { recursive: true })
+  if (!fromDir || !fs.existsSync(fromDir)) {
+    throw new Error('automationsDir is missing')
+  }
+  const names = fs.readdirSync(fromDir).filter((f) => /\.ya?ml$/i.test(f))
+  for (const name of names) {
+    fs.copyFileSync(path.join(fromDir, name), path.join(toDir, name))
+  }
+  return names
+}
+
+function switchLogPath (dir) {
+  return path.join(dir, 'switch-log.json')
+}
+
+function loadSwitchLog (dir) {
+  try {
+    const data = JSON.parse(fs.readFileSync(switchLogPath(dir), 'utf8'))
+    return Array.isArray(data) ? data : []
+  } catch (_) {
+    return []
+  }
+}
+
+function appendSwitchLog (dir, entry, max) {
+  const cap = max > 0 ? max : 50
+  const list = loadSwitchLog(dir)
+  list.unshift(entry)
+  while (list.length > cap) list.pop()
+  fs.mkdirSync(dir, { recursive: true })
+  const tmp = switchLogPath(dir) + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(list, null, 2) + '\n')
+  fs.renameSync(tmp, switchLogPath(dir))
+  return list
+}
+
 function safeId (id) {
   return String(id || 'unknown').replace(/[^A-Za-z0-9._-]+/g, '_')
 }
@@ -71,5 +109,8 @@ module.exports = {
   loadTraces,
   appendTrace,
   liveDir,
-  tracesPath
+  tracesPath,
+  copyYamlFiles,
+  loadSwitchLog,
+  appendSwitchLog
 }

package/lib/yaml.js

@@ -167,14 +167,24 @@ function mergeAutomations (result, list, file) {
       id: String(raw.id),
       file,
       alias: raw.alias || raw.id,
-      enabled: raw.enabled !== false,
       trigger: asArray(raw.trigger),
       condition: asArray(raw.condition),
       action: asArray(raw.action),
       choose: Array.isArray(raw.choose) ? raw.choose : [],
       debounceMs: raw.debounceMs || 0,
-      edge: raw.edge || 'rising'
+      edge: raw.edge || 'every'
     })
+    for (const t of asArray(raw.trigger)) {
+      if (!t || t.round == null) continue
+      const n = Number(t.round)
+      if (!Number.isFinite(n) || n <= 0) {
+        result.errors.push({
+          file,
+          message: 'Automation ' + raw.id + ': round must be a positive number'
+        })
+      }
+    }
+    if (raw.zones) mergeZones(result, raw.zones, file)
   }
 }
 
@@ -194,11 +204,83 @@ function combinedYaml (doc) {
   return parts.join('\n\n---\n\n')
 }
 
+function escapeRegExp (s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function extractIndentedBlock (text, startLine, baseIndent) {
+  const lines = text.split('\n')
+  let end = startLine + 1
+  while (end < lines.length) {
+    const line = lines[end]
+    if (line.trim() === '') {
+      end++
+      continue
+    }
+    const indent = (line.match(/^[ \t]*/) || [''])[0]
+    if (indent.length <= baseIndent.length) break
+    end++
+  }
+  while (end > startLine + 1 && lines[end - 1].trim() === '') end--
+  return lines.slice(startLine, end).join('\n').replace(/\s+$/, '') + '\n'
+}
+
+function extractListItemById (text, id) {
+  if (!text || !id) return null
+  const lines = text.split('\n')
+  const idRe = new RegExp('^- id:\\s*["\']?' + escapeRegExp(id) + '["\']?\\s*$')
+  for (let i = 0; i < lines.length; i++) {
+    const indent = (lines[i].match(/^[ \t]*/) || [''])[0]
+    const rest = lines[i].slice(indent.length)
+    if (idRe.test(rest)) return extractIndentedBlock(text, i, indent)
+  }
+  return null
+}
+
+function extractMappingEntry (text, id) {
+  if (!text || !id) return null
+  const lines = text.split('\n')
+  const keyRe = new RegExp('^' + escapeRegExp(id) + ':\\s*(.*)$')
+  for (let i = 0; i < lines.length; i++) {
+    const indent = (lines[i].match(/^[ \t]*/) || [''])[0]
+    const rest = lines[i].slice(indent.length)
+    const m = rest.match(keyRe)
+    if (!m) continue
+    if (m[1] && m[1].trim() && !m[1].trim().startsWith('#') && !m[1].trim().startsWith('|') && !m[1].trim().startsWith('>')) {
+      return lines[i].replace(/\s+$/, '') + '\n'
+    }
+    return extractIndentedBlock(text, i, indent)
+  }
+  return null
+}
+
+function snippetAutomation (doc, id) {
+  for (const file of doc.files || []) {
+    const text = doc.rawText && doc.rawText[file]
+    const block = extractListItemById(text, id)
+    if (block) return block
+  }
+  return ''
+}
+
+function snippetHelper (doc, id) {
+  for (const file of doc.files || []) {
+    const text = doc.rawText && doc.rawText[file]
+    const block = extractMappingEntry(text, id)
+    if (block) return block
+  }
+  return ''
+}
+
 module.exports = {
   ON_START,
   HELPER_TYPES,
   loadYamlDir,
   loadYamlText,
   emptyDoc,
-  combinedYaml
+  combinedYaml,
+  extractListItemById,
+  extractMappingEntry,
+  snippetAutomation,
+  snippetHelper
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-automation-plugin",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Home Assistant-like YAML automations for Signal K",
   "main": "plugin/index.js",
   "keywords": [
@@ -20,6 +20,7 @@
   },
   "homepage": "https://github.com/htool/signalk-automation-plugin#readme",
   "signalk": {
+    "appIcon": "icon.png",
     "displayName": "Automations"
   },
   "signalk-plugin-enabled-by-default": false,