sailkick-boat 0.17.0 → 0.18.0

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
@@ -201,9 +217,30 @@ backfill runs: **revoke it afterwards**, live sync is unaffected.
 
 Safe to re-run. Points are keyed by (measurement, tagset, nanosecond timestamp), so an
 identical point overwrites rather than duplicating — an interrupted migration is simply
-run again. Everything in the bucket is copied, including AIS contexts; hand-edit
-`backfill.selfOnly: true` to restrict it to your own vessel if cloud series cardinality
-becomes a problem.
+run again.
+
+**Only this boat's data is copied**, and that is not configurable. The cloud's history
+queries assume your bucket holds one vessel, so uploading an archive's AIS would put
+other ships into your own SOG and heading charts. If the source holds several contexts
+the plugin copies yours and logs which it skipped. If it holds exactly **one** context it
+is copied whatever identity string it uses — a bucket with one vessel cannot be an AIS
+collection, and this is what lets an archive recorded under an older Signal K UUID (or an
+MMSI URN) still migrate. Hand-edit `backfill.context` to force a specific one.
+
+A run that copies **zero** points is reported as a problem, not as success: that almost
+always means the org or bucket is wrong rather than that the archive is empty.
+
+**It starts below what live sync already covers.** The destination's own oldest point is
+the moment cloud sync began, so the walk begins there rather than at *now*. Without that,
+a source archive that is still being written — a `signalk-to-influxdb-v2` bucket still
+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.
+
+**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
+is halved until it fits, down to a one-minute floor. The count is already known before
+the read, so this costs nothing extra.
 
 **True wind comes from your instruments.** If the boat publishes
 `environment.wind.speedTrue` / `directionTrue`, those are stored verbatim — a wind

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, {})
@@ -373,7 +388,10 @@ module.exports = function (app) {
           backfill = createBackfill(app, {
             src,
             dst,
-            selfOnly: bf.selfOnly === true,
+            // Never a config option: the plugin must not upload data that is not this
+            // boat's, and the cloud's history queries depend on that holding.
+            selfContext: app.selfContext || ('vessels.' + (app.selfId || 'self')),
+            context: String(bf.context || '').trim() || null, // hand-edit escape hatch
             startBound: bf.startBound,
             stateFile: path.join((app.getDataDirPath && app.getDataDirPath()) || '.', 'backfill.json'),
             pending: sync ? sync.pending : null
@@ -399,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 {}
@@ -410,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 {}
@@ -418,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

@@ -29,7 +29,13 @@ const HOUR_MS = 3600000
 const DEFAULTS = {
   windowMs: HOUR_MS,
   batchSize: 10000,
-  idleMs: 2000, // breathing room between windows so a slow link isn't monopolised
+  // A window is read whole and converted in memory. A busy archive can hold millions of
+  // points per hour (54M/day was measured on a real boat = ~2.25M/hour ~ 400 MB of CSV),
+  // which would exhaust a Raspberry Pi. When a window is denser than this it is halved
+  // until it fits — the count is already known before the read, so this costs nothing.
+  maxRowsPerChunk: 100000,
+  minWindowMs: 60000, // never subdivide below a minute
+  idleMs: 250, // pending() is the real backpressure; this is just politeness
   backlogWaitMs: 15000, // how long to stand down when live sync has a backlog
   maxErrorStreak: 5,
   queryTimeoutMs: 120000
@@ -59,9 +65,9 @@ function createBackfill (app, options) {
   function load () {
     try {
       const j = JSON.parse(fs.readFileSync(cfg.stateFile, 'utf8'))
-      if (j && typeof j === 'object') return { done: j.done || {}, earliest: j.earliest || null, points: j.points || 0, complete: !!j.complete }
+      if (j && typeof j === 'object') return { done: j.done || {}, earliest: j.earliest || null, ceiling: j.ceiling || null, points: j.points || 0, complete: !!j.complete }
     } catch {}
-    return { done: {}, earliest: null, points: 0, complete: false }
+    return { done: {}, earliest: null, ceiling: null, points: 0, complete: false }
   }
   function save () {
     try {
@@ -106,12 +112,12 @@ function createBackfill (app, options) {
     return 0
   }
 
-  async function earliestPoint () {
+  async function earliestPoint (conn = cfg.src, bucket = cfg.src.bucket) {
     // `first()` reduces each series before anything is merged, then _time is isolated
     // BEFORE group(). Both matter on a real bucket: grouping the raw stream fails with
     // "schema collision: cannot group boolean and integer types together" the moment the
     // database holds more than one field type, which any real boat's does.
-    const r = await flux(cfg.src, `from(bucket:"${cfg.src.bucket}")|>range(start:0)|>first()|>keep(columns:["_time"])|>group()|>min(column:"_time")`)
+    const r = await flux(conn, `from(bucket:"${bucket}")|>range(start:0)|>first()|>keep(columns:["_time"])|>group()|>min(column:"_time")`)
     if (!r.ok) return null
     for (const line of r.text.split('\n')) {
       if (!line || line.startsWith('#') || line.includes('_time')) continue
@@ -128,18 +134,70 @@ function createBackfill (app, options) {
     return null
   }
 
+  // Distinct contexts in the source bucket. Returns null on any failure — never an
+  // empty list, so an unreachable database is not mistaken for an empty archive.
+  async function sourceContexts () {
+    const r = await flux(cfg.src, `import "influxdata/influxdb/schema"\nschema.tagValues(bucket:"${cfg.src.bucket}", tag:"context")`)
+    if (!r.ok) return null
+    const out = []
+    for (const line of r.text.split('\n')) {
+      if (!line || line.startsWith('#')) continue
+      const cells = line.trim().split(',')
+      const v = cells[cells.length - 1]
+      if (v && v !== '_value') out.push(v)
+    }
+    return out
+  }
+
+  // The plugin must never upload data that is not this boat's. Live sync guarantees
+  // that by subscribing to vessels.self; the backfill is the only thing that could
+  // break it, and the cloud's history queries depend on it holding. So this is decided
+  // in code, not exposed as an option someone can get wrong.
+  //
+  // The wrinkle: an imported archive may carry a DIFFERENT context than the boat's
+  // current identity — a UUID from a since-reinstalled Signal K, or an MMSI URN. A
+  // strict match would then copy nothing, silently. Hence the single-context rule: a
+  // bucket holding exactly one context contains one vessel by definition and cannot be
+  // an AIS collection, so it is copied whatever its identity string says.
+  function contextFilterFor (contexts) {
+    const selfCtx = cfg.selfContext
+    if (cfg.context) {
+      log(`copying only context ${cfg.context} (explicit override)`)
+      return `|>filter(fn:(r)=>r.context=="${cfg.context}")`
+    }
+    if (contexts.length <= 1) {
+      log(`source holds a single context (${contexts[0] || 'none'}) — copying all of it`)
+      return ''
+    }
+    const others = contexts.filter((c) => c !== selfCtx)
+    warn(`source holds ${contexts.length} contexts — copying only this boat (${selfCtx}) and skipping ${others.length} other(s), e.g. ${others.slice(0, 3).join(', ')}`)
+    return `|>filter(fn:(r)=>r.self=="true" or r.context=="${selfCtx}")`
+  }
+
   // --- one window ---------------------------------------------------------------
-  // Returns 'done' | 'empty' | 'retry' | 'stopped'.
+  // Returns 'done' | 'empty' | 'retry' | 'fatal' | 'stopped'. Subdivides itself when a
+  // window holds more points than can be held in memory at once.
   async function doWindow (startMs, stopMs) {
     const srcCount = await count(cfg.src, cfg.src.bucket, startMs, stopMs)
     if (srcCount == null) return 'retry'
     if (srcCount === 0) return 'empty'
 
-    const filter = cfg.selfOnly ? '|>filter(fn:(r)=>r.self=="true")' : ''
+    if (srcCount > cfg.maxRowsPerChunk && (stopMs - startMs) > cfg.minWindowMs) {
+      // Too dense to read whole. Halve it — newest half first, keeping the run's
+      // newest-first order. Both halves must succeed for the caller to mark the window
+      // done, so a failure part-way is simply retried next time.
+      const mid = startMs + Math.floor((stopMs - startMs) / 2)
+      log(`${iso(startMs)} holds ${srcCount} points — splitting`)
+      const newer = await doWindow(mid, stopMs)
+      if (newer !== 'done' && newer !== 'empty') return newer
+      return doWindow(startMs, mid)
+    }
+
+    const filter = cfg._filter || ''
     const r = await flux(cfg.src, `from(bucket:"${cfg.src.bucket}")|>range(start:${iso(startMs)},stop:${iso(stopMs)})${filter}|>drop(columns:["_start","_stop"])`)
     if (!r.ok) { warn(`read ${iso(startMs)} failed — ${r.message}`); return 'retry' }
 
-    const { lines, skipped } = csvToLineProtocol(r.text, { selfOnly: cfg.selfOnly })
+    const { lines, skipped } = csvToLineProtocol(r.text)
     if (skipped) log(`${iso(startMs)}: skipped ${skipped} unconvertible row(s)`)
     if (!lines.length) return 'empty'
 
@@ -171,6 +229,16 @@ function createBackfill (app, options) {
   async function run () {
     running = true
     try {
+      // Validate the source and decide the filter before walking 15k windows.
+      const contexts = await sourceContexts()
+      if (contexts == null) { warn(`could not read contexts from ${cfg.src.bucket} — is the source reachable?`); statusLine = 'backfill: source unreachable'; return }
+      if (!contexts.length) {
+        warn(`source bucket "${cfg.src.bucket}" (org "${cfg.src.org}") holds no data at all — check the org and bucket names`)
+        statusLine = `backfill: source ${cfg.src.org}/${cfg.src.bucket} is empty — check the names`
+        return
+      }
+      cfg._filter = contextFilterFor(contexts)
+
       if (state.earliest == null) {
         const e = await earliestPoint()
         if (e == null) { warn('could not read the oldest point from the source — is it reachable?'); statusLine = 'backfill: source unreachable'; return }
@@ -186,7 +254,20 @@ function createBackfill (app, options) {
       const rawFloor = cfg.startBound ? Math.max(state.earliest, Date.parse(cfg.startBound)) : state.earliest
       const floor = hourFloor(rawFloor)
 
-      let cursor = hourFloor(Date.now()) // newest-first: recent history lands first
+      // Start below where live sync has already delivered, not at "now". A still-live
+      // source archive otherwise makes the first windows re-upload today's data —
+      // correct timestamps, but data the cloud already has, and a lot of wasted uplink.
+      // The destination's own oldest point IS the moment cloud sync began, and the
+      // read+write token can see it.
+      if (state.ceiling == null) {
+        const dstOldest = await earliestPoint(cfg.dst, cfg.dst.bucket)
+        state.ceiling = dstOldest != null ? hourFloor(dstOldest) : hourFloor(Date.now())
+        log(dstOldest != null
+          ? `live sync covers everything from ${iso(state.ceiling)} — backfilling only what is older`
+          : 'destination is empty — backfilling everything up to now')
+        save()
+      }
+      let cursor = state.ceiling // newest-first: recent history lands first
       let errStreak = 0
       let didWork = 0
 
@@ -223,6 +304,16 @@ function createBackfill (app, options) {
       }
 
       if (!stopped && cursor < floor) {
+        if (state.points === 0) {
+          // A walk that finishes having copied nothing is far more likely to be a wrong
+          // org/bucket, or a filter that matched no rows, than a genuinely empty
+          // archive. Marking it complete would dress a silent no-op as success and stop
+          // it ever retrying.
+          save()
+          warn(`walked ${Object.keys(state.done).length} window(s) and copied ZERO points — check that org "${cfg.src.org}" / bucket "${cfg.src.bucket}" is right, and that its data belongs to this boat. NOT marking complete.`)
+          statusLine = `backfill: finished with 0 points — check ${cfg.src.org}/${cfg.src.bucket}`
+          return
+        }
         state.complete = true
         save()
         statusLine = `backfill: complete — ${state.points} point(s) from ${iso(floor).slice(0, 10)}`
@@ -242,7 +333,7 @@ function createBackfill (app, options) {
     if (state.complete) { statusLine = `backfill: complete — ${state.points} point(s)`; return null }
     if (!cfg.src.token || !cfg.src.bucket || !cfg.src.url) { statusLine = 'backfill: not configured (source)'; return null }
     if (!cfg.dst.token || !cfg.dst.bucket) { statusLine = 'backfill: not configured (cloud token)'; return null }
-    log(`${cfg.src.url} ${cfg.src.org}/${cfg.src.bucket} -> ${cfg.dst.url} ${cfg.dst.org}/${cfg.dst.bucket}${cfg.selfOnly ? ' [self only]' : ''}`)
+    log(`${cfg.src.url} ${cfg.src.org}/${cfg.src.bucket} -> ${cfg.dst.url} ${cfg.dst.org}/${cfg.dst.bucket}`)
     statusLine = 'backfill: starting'
     runPromise = run().catch((e) => { warn('run failed: ' + e.message); statusLine = 'backfill: error — ' + e.message })
     return runPromise

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.0",
+  "version": "0.18.0",
   "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": {