sailkick-boat 0.17.2 → 0.18.1

package/README.md

@@ -155,6 +155,22 @@ A local InfluxDB is not a competitor here anyway. The app never requests finer t
 `ringSampleSec: 5` and it matches anything the UI can draw, from live state. What an old
 database *is* good for is its contents ending up **in the cloud** — see below.
 
+## AIS on the boat's own chart
+The app draws other vessels from `GET /api/ais`. The cloud serves that by polling a
+SignalK server over the LAN and gates it behind a boat session — neither of which can
+work from a boat on a mobile link, and the mirror forwards no cookies, so proxying it
+returns 401 whatever you do.
+
+The plugin therefore serves `/api/ais` **from the boat's own SignalK**, in the same
+envelope the app already consumes: position, SOG, COG, heading, rate of turn, name,
+dimensions and ship type, plus a ~1 h trail per vessel. Anchored ships stay a single dot
+— a trail point is added only once a vessel has moved more than 30 m — and a target
+unheard for 15 min is dropped. A failed poll keeps the last snapshot rather than blanking
+the chart.
+
+This works **with no uplink at all**, which is when other vessels on your chart matter
+most. Turn it off by hand-editing `proxy.serveAis: false`.
+
 ## Uploading AIS targets
 The cloud app already draws other vessels, but its AIS source polls a SignalK server over
 the LAN and keeps everything in memory — which cannot work once a boat is on a mobile
@@ -220,6 +236,13 @@ a source archive that is still being written — a `signalk-to-influxdb-v2` buck
 recording — makes the first windows re-upload today's data. The timestamps are correct,
 but it is data the cloud already has, and a lot of wasted uplink.
 
+**Field types come from the source, not from guessing.** Queries ask InfluxDB for the
+`#datatype` annotation explicitly. Without it the response is unannotated and types have
+to be inferred from the text — which fails hard on a string field whose values sometimes
+look numeric (`"8"` emitted bare as a float, `"1.2.3.4"` quoted as a string), producing
+`422 field type conflict` and aborting the run. Integers also keep their type instead of
+silently becoming floats.
+
 **Dense archives are subdivided.** A window is read whole and converted in memory, and a
 busy boat can produce millions of points an hour (54M/day was measured on a real boat —
 about 400 MB of CSV per hour). When a window holds more than `maxRowsPerChunk` points it

package/index.js

@@ -8,6 +8,7 @@ const { createTelemetry } = require('./lib/telemetry')
 const { createHistory } = require('./lib/history')
 const { createBackfill } = require('./lib/backfill')
 const { createAis } = require('./lib/ais')
+const { createAisTargets } = require('./lib/ais/targets')
 const { resolveAccountConfig } = require('./lib/account')
 
 // sailkick-boat: one Signal K plugin, two independently-toggleable modules —
@@ -94,6 +95,7 @@ module.exports = function (app) {
   let history = null
   let backfill = null
   let ais = null
+  let aisTargets = null
   let statusTimer = null
   let accountStatus = null
   let syncWarning = null
@@ -291,6 +293,19 @@ module.exports = function (app) {
         }
       }
 
+      // AIS targets for the boat's own browser, from local SignalK. Independent of the
+      // AIS upload above: this one works with no uplink, which is when it matters most.
+      if (p.serveAis !== false) {
+        try {
+          aisTargets = createAisTargets(app, { localSignalkUrl: pOpts.localSignalkUrl })
+          aisTargets.start()
+          pOpts.aisTargets = aisTargets
+        } catch (e) {
+          (app.error || console.error)('[sailkick-boat] AIS targets start failed: ' + e.message)
+          aisTargets = null
+        }
+      }
+
       if (p.serveTelemetry !== false) {
         try {
           telemetry = createTelemetry(app, {})
@@ -402,6 +417,7 @@ module.exports = function (app) {
     if (proxy) parts.push(proxy.status())
     if (telemetry) parts.push(telemetry.status())
     if (history) parts.push(history.status())
+    if (aisTargets) parts.push(aisTargets.status())
     if (ais) parts.push(ais.status())
     if (backfill) parts.push(backfill.status())
     try { app.setPluginStatus(parts.join('   |   ') || 'idle (both features off)') } catch {}
@@ -413,6 +429,7 @@ module.exports = function (app) {
     try { if (sync) sync.stop() } catch {}
     try { if (telemetry) telemetry.stop() } catch {}
     try { if (history) history.stop() } catch {}
+    try { if (aisTargets) aisTargets.stop() } catch {}
     try { if (ais) ais.stop() } catch {}
     try { if (backfill) backfill.stop() } catch {}
     try { if (proxy) proxy.stop() } catch {}
@@ -421,6 +438,7 @@ module.exports = function (app) {
     history = null
     backfill = null
     ais = null
+    aisTargets = null
     proxy = null
     accountStatus = null
     syncWarning = null

package/lib/ais/targets.js

@@ -0,0 +1,171 @@
+'use strict'
+
+// Serve the app's GET /api/ais from the boat's OWN SignalK, so other vessels appear on
+// the chart with no uplink at all.
+//
+// Ported from the cloud's server/ais/service.js — same polling shape, same trail rules,
+// same JSON envelope — so public/viewer/ais.js cannot tell the difference. Keep the
+// field set and the trail thresholds in step with that copy.
+//
+// This is the counterpart of lib/ais/index.js, not a duplicate of it: that one pushes
+// AIS to the cloud so the boat's surroundings can be seen from shore; this one answers
+// the browser sitting on the boat. Offshore, only this one can work — and it is the more
+// valuable of the two, since AIS targets on your own chart matter most exactly when
+// there is no connectivity.
+//
+// Why not reuse the upload module's delta stream? It subscribes only to the paths it
+// forwards, and a vessel's NAME arrives as a vessel-level delta (empty path) which that
+// path list deliberately ignores. Polling the REST tree gets identity and dimensions
+// without a second subscription, exactly as the cloud does.
+
+const MS_TO_KT = 1.94384
+const R2D = 180 / Math.PI
+const num = (x) => (Number.isFinite(Number(x)) ? Number(x) : null)
+const wrap360 = (d) => ((d % 360) + 360) % 360
+
+// ws/wss/http, with or without a /signalk path → REST origin.
+function restOrigin (url) {
+  return String(url || '').trim()
+    .replace(/\/+$/, '')
+    .replace(/\/signalk\/.*$/i, '')
+    .replace(/^ws(s?):\/\//i, 'http$1://')
+}
+
+function haversineM (lat1, lon1, lat2, lon2) {
+  const toR = Math.PI / 180
+  const R = 6371000
+  const dLat = (lat2 - lat1) * toR
+  const dLon = (lon2 - lon1) * toR
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1 * toR) * Math.cos(lat2 * toR) * Math.sin(dLon / 2) ** 2
+  return 2 * R * Math.asin(Math.min(1, Math.sqrt(a)))
+}
+
+function createAisTargets (app, options = {}) {
+  const log = (m) => (app.debug ? app.debug('[ais-targets] ' + m) : console.log('[sailkick-boat:ais-targets]', m))
+  const cfg = {
+    url: options.localSignalkUrl || 'http://127.0.0.1:3000',
+    pollMs: options.pollMs || 10000,
+    trailMs: options.trailMs || 3600000, // ~1 h of trail
+    trailMinMoveM: options.trailMinMoveM || 30, // a point only after moving this far
+    trailMaxPoints: options.trailMaxPoints || 240,
+    staleMs: options.staleMs || 15 * 60000 // drop a vessel unseen for this long
+  }
+  const base = restOrigin(cfg.url)
+  const state = new Map() // mmsi -> record
+  let selfMmsi = null
+  let lastPollAt = null
+  let lastError = null
+  let stopped = false
+  let timer = null
+
+  async function fetchSelf () {
+    try {
+      const r = await fetch(`${base}/signalk/v1/api/self`, { signal: AbortSignal.timeout(5000) })
+      if (r.ok) selfMmsi = String(await r.json()).split(':').pop() // "vessels.urn:…:mmsi:<n>"
+    } catch { /* retry next poll */ }
+  }
+
+  function ingest (vessels) {
+    const now = Date.now()
+    for (const [key, v] of Object.entries(vessels || {})) {
+      const mmsi = String(key).split(':').pop()
+      if (!mmsi || mmsi === selfMmsi) continue
+      const p = v && v.navigation && v.navigation.position && v.navigation.position.value
+      if (!p || !Number.isFinite(p.latitude) || !Number.isFinite(p.longitude)) continue
+      // The AIS message's own time, beside .value — the poll cadence is not the age of
+      // the report.
+      const posTs = Date.parse(v.navigation.position.timestamp) || now
+
+      const cog = num(v.navigation.courseOverGroundTrue && v.navigation.courseOverGroundTrue.value)
+      const hT = num(v.navigation.headingTrue && v.navigation.headingTrue.value)
+      const hM = num(v.navigation.headingMagnetic && v.navigation.headingMagnetic.value)
+      const varn = num(v.navigation.magneticVariation && v.navigation.magneticVariation.value)
+      const headingDeg = hT != null ? wrap360(hT * R2D) : hM != null ? wrap360((hM + (varn || 0)) * R2D) : null
+
+      const rec = state.get(mmsi) || { mmsi, trail: [] }
+      // SignalK exposes `name` as a bare string, not the usual {value} wrapper.
+      rec.name = (typeof v.name === 'string' ? v.name : v.name && v.name.value) || rec.name || null
+      rec.lat = p.latitude
+      rec.lon = p.longitude
+      const sog = num(v.navigation.speedOverGround && v.navigation.speedOverGround.value)
+      rec.sogKt = sog != null ? +(sog * MS_TO_KT).toFixed(1) : null
+      rec.cogDeg = cog != null ? wrap360(cog * R2D) : null
+      rec.headingDeg = headingDeg
+      const len = v.design && v.design.length && v.design.length.value
+      rec.loaM = num(len && (len.overall != null ? len.overall : len.hull != null ? len.hull : len))
+      rec.beamM = num(v.design && v.design.beam && v.design.beam.value)
+      const at = v.design && v.design.aisShipType && v.design.aisShipType.value // { id, name } | id
+      rec.shipType = (at && typeof at === 'object' ? at.name : null) || rec.shipType || null
+      rec.aisType = (typeof at === 'number' ? at : num(at && at.id)) || rec.aisType || null
+      rec.rotRadS = num(v.navigation.rateOfTurn && v.navigation.rateOfTurn.value)
+      rec.posTs = posTs
+      rec.updatedAt = now
+
+      // Trail: a point only once the vessel has actually moved, so anchored ships stay a
+      // single dot instead of a jittering cloud.
+      const last = rec.trail[rec.trail.length - 1]
+      if (!last || haversineM(last[0], last[1], p.latitude, p.longitude) > cfg.trailMinMoveM) {
+        rec.trail.push([p.latitude, p.longitude, now])
+      }
+      const cutoff = now - cfg.trailMs
+      while (rec.trail.length && rec.trail[0][2] < cutoff) rec.trail.shift()
+      if (rec.trail.length > cfg.trailMaxPoints) rec.trail.splice(0, rec.trail.length - cfg.trailMaxPoints)
+
+      state.set(mmsi, rec)
+    }
+  }
+
+  async function poll () {
+    if (stopped) return
+    try {
+      if (!selfMmsi) await fetchSelf()
+      const r = await fetch(`${base}/signalk/v1/api/vessels`, { signal: AbortSignal.timeout(8000) })
+      if (!r.ok) throw new Error(`vessels ${r.status}`)
+      ingest(await r.json())
+      lastPollAt = Date.now()
+      lastError = null
+    } catch (e) {
+      lastError = e.message // a failed poll keeps the last snapshot; never throws
+    } finally {
+      if (!stopped) { timer = setTimeout(poll, cfg.pollMs); if (timer.unref) timer.unref() }
+    }
+  }
+
+  function getVessels () {
+    const cutoff = Date.now() - cfg.staleMs
+    const vessels = []
+    for (const rec of state.values()) {
+      if (rec.updatedAt < cutoff) { state.delete(rec.mmsi); continue }
+      vessels.push({
+        mmsi: rec.mmsi, name: rec.name, lat: rec.lat, lon: rec.lon,
+        sogKt: rec.sogKt, cogDeg: rec.cogDeg, headingDeg: rec.headingDeg, rotRadS: rec.rotRadS,
+        loaM: rec.loaM, beamM: rec.beamM, shipType: rec.shipType, aisType: rec.aisType,
+        posTs: rec.posTs, updatedAt: rec.updatedAt,
+        trail: rec.trail.map((q) => [q[0], q[1]])
+      })
+    }
+    return { polledAt: lastPollAt, error: lastError, count: vessels.length, vessels }
+  }
+
+  function start () { log(`polling ${base}/signalk/v1/api/vessels every ${Math.round(cfg.pollMs / 1000)}s`); poll() }
+  function stop () { stopped = true; if (timer) clearTimeout(timer) }
+  function available () { return true } // SignalK is local; a failed poll just serves the last snapshot
+
+  // GET /api/ais — byte-for-byte the envelope the cloud returns.
+  function handleAis (req, res) {
+    const body = JSON.stringify({ available: true, ...getVessels() })
+    res.statusCode = 200
+    res.setHeader('Content-Type', 'application/json')
+    res.end(req.method === 'HEAD' ? undefined : body)
+  }
+
+  function status () {
+    const n = state.size
+    const age = lastPollAt ? Math.round((Date.now() - lastPollAt) / 1000) + 's ago' : 'never'
+    return `ais targets: ${n} vessel(s), polled ${age}${lastError ? ' (' + lastError + ')' : ''}`
+  }
+
+  return { start, stop, status, available, handleAis, getVessels, _ingest: ingest, _state: () => state }
+}
+
+module.exports = { createAisTargets, restOrigin, haversineM }

package/lib/backfill/index.js

@@ -79,14 +79,26 @@ function createBackfill (app, options) {
   }
 
   // --- InfluxDB reads -----------------------------------------------------------
+  // Always ask for the #datatype annotation. A raw-Flux body (Content-Type
+  // application/vnd.flux) cannot carry a dialect, and InfluxDB then returns UNANNOTATED
+  // CSV — so field types have to be guessed from the text, and guessing is wrong in a
+  // way that breaks the write outright.
+  //
+  // The case that bit: a STRING field whose values sometimes look numeric. "8" is
+  // emitted bare (a float) while "1.2.3.4" is quoted (a string), so one batch declares
+  // two types for one field and InfluxDB rejects the lot with
+  //   422 field type conflict: input field "value" on measurement "network..."
+  // With the annotation the source declares `string` and every value is quoted
+  // consistently. Integers keep their `i` suffix too, instead of silently becoming
+  // floats.
   async function flux (conn, body) {
     const url = `${conn.url.replace(/\/+$/, '')}/api/v2/query?org=${encodeURIComponent(conn.org)}`
     let resp
     try {
       resp = await fetch(url, {
         method: 'POST',
-        headers: { Authorization: `Token ${conn.token}`, 'Content-Type': 'application/vnd.flux', Accept: 'application/csv' },
-        body,
+        headers: { Authorization: `Token ${conn.token}`, 'Content-Type': 'application/json', Accept: 'application/csv' },
+        body: JSON.stringify({ type: 'flux', query: body, dialect: { header: true, annotations: ['datatype'] } }),
         signal: AbortSignal.timeout(cfg.queryTimeoutMs)
       })
     } catch (e) { return { ok: false, message: e.message } }

package/lib/proxy/index.js

@@ -57,6 +57,7 @@ function createProxy (app, options) {
       localPaths: (options.localPaths && options.localPaths.length) ? options.localPaths : ['/signalk'],
       telemetryPath: options.telemetryPath || '/ws/telemetry',
       history: options.history || null,
+      aisTargets: options.aisTargets || null,
       openAccess: options.openAccess !== false
     }
     log(`mirroring ${cfg.upstream}; local SignalK ${cfg.localSignalk}; store ${cfg.storeDir}`)
@@ -140,6 +141,15 @@ function createProxy (app, options) {
       if (pathname === '/api/history/series') return cfg.history.handleSeries(req, res)
       if (pathname === '/api/history/track') return cfg.history.handleTrack(req, res)
     }
+    // AIS targets, from the boat's own SignalK. The cloud's /api/ais is gated behind a
+    // boat session the mirror can never hold (it forwards no cookies), and its poller
+    // reads a LAN address it cannot reach once the boat is on a mobile link — so
+    // proxying it returns 401 whatever we do. Served locally it also works with no
+    // uplink at all, which is when other vessels on the chart matter most.
+    if (req.method === 'GET' && cfg.aisTargets && cfg.aisTargets.available() &&
+        req.url.split('?')[0] === '/api/ais') {
+      return cfg.aisTargets.handleAis(req, res)
+    }
     // /api/config drives the app's login gate + Trends toggle. On the single-tenant
     // boat we serve it with auth turned off (no cloud login over the offline HTTP
     // mirror) and history forced on when we serve it locally. All other config passes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sailkick-boat",
-  "version": "0.17.2",
+  "version": "0.18.1",
   "description": "EARLY ALPHA — cloud telemetry + offline maps for sailkick boats (www.sailkick.io; register on the web, paste the write token). Gapless boat→cloud telemetry sync to InfluxDB, and a local proxy that keeps the sailkick app and its charts/maps working fully offline on board.",
   "main": "index.js",
   "scripts": {