kahu-signalk 0.0.1

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "data/protocol"]
+	path = data/protocol
+	url = https://github.com/KAHU-radar/radarhub-protocol.git

package/README.md

@@ -0,0 +1,195 @@
+# KAHU Radar Hub
+
+*A crowdsourcing [Signal K](https://signalk.org/) plugin for marine safety*
+
+---
+
+## What Does This Plugin Do?
+
+This plugin takes **radar target data** from your boat and uploads it to a shared server so that other mariners can benefit from the information. Think of it like Waze for boats -- your radar sees nearby vessels and objects, and this plugin shares that data to help build a bigger picture of what's happening on the water.
+
+### The Big Picture
+
+```
+Your Boat's Radar
+      |
+      | detects targets (other boats, obstacles)
+      v
+  Radar Unit  ──NMEA sentences──>  Signal K Server
+                                        |
+                                        | this plugin parses the data
+                                        v
+                                   KAHU Radar Hub Plugin
+                                        |
+                                        | uploads via TCP/Avro
+                                        v
+                                   KAHU Cloud Server
+                                   (crowdsource.kahu.earth)
+```
+
+---
+
+## Key Concepts Explained
+
+### What is NMEA?
+
+**NMEA** (National Marine Electronics Association) is the standard "language" that marine electronics use to talk to each other. When your GPS, radar, depth sounder, or wind instrument sends data, it sends it as **NMEA sentences** -- short text messages with a specific format.
+
+For example, a GPS position might look like: `$GPGGA,123519,4807.038,N,01131.000,E,...`
+
+There are two main versions:
+- **NMEA 0183** -- the older serial/text-based standard (what this plugin uses)
+- **NMEA 2000** -- the newer CAN-bus based standard
+
+### What is ARPA?
+
+**ARPA** (Automatic Radar Plotting Aid) is a feature built into marine radars. When your radar detects an object (another boat, a buoy, land), ARPA automatically:
+
+1. **Tracks** the object over time
+2. **Calculates** its speed and course
+3. **Predicts** its future position
+4. **Computes CPA** (Closest Point of Approach) -- how close it will get to you and when
+
+ARPA is a critical safety tool for collision avoidance. Without ARPA, a radar just shows blips; with ARPA, those blips become tracked targets with speed, heading, and collision risk information.
+
+### What is $RATTM?
+
+`$RATTM` is the specific NMEA 0183 sentence that a radar sends when reporting an ARPA-tracked target. The "RA" prefix means it comes from a **Radar**, and "TTM" stands for **Tracked Target Message**.
+
+A `$RATTM` sentence contains:
+| Field | Meaning |
+|-------|---------|
+| Target number | Which tracked target (00-99) |
+| Distance | How far away the target is |
+| Bearing | What direction the target is in (degrees) |
+| Speed | How fast the target is moving |
+| Course | What direction the target is heading |
+| CPA distance | Closest the target will come to you |
+| CPA time | When it will be closest |
+| Target name | Optional identifier |
+| Target status | Tracking status (e.g. lost, tracking) |
+
+### What is Signal K?
+
+[Signal K](https://signalk.org/) is a modern, open-source data format and server for boats. It acts as a central hub that collects data from all your marine instruments (GPS, radar, AIS, wind, depth, etc.) and makes it available in a standard JSON format over your boat's network. Apps and plugins can then read and process this data.
+
+### What is Apache Avro?
+
+[Apache Avro](https://avro.apache.org/) is a compact binary data format. This plugin uses it instead of JSON or plain text to send data to the server because it is much smaller -- important when you're on a boat with limited or expensive satellite/cellular internet.
+
+### What is AIS?
+
+**AIS** (Automatic Identification System) is a tracking system used on ships. Vessels equipped with AIS transponders automatically broadcast their identity, position, course, and speed. Unlike radar (which detects objects passively), AIS requires the other vessel to be actively transmitting. This plugin currently does **not** collect AIS data -- only radar ARPA targets.
+
+---
+
+## How It Works (Step by Step)
+
+1. **Your radar** detects nearby objects and tracks them using ARPA
+2. **The radar sends** `$RATTM` NMEA sentences to Signal K (via a serial/network connection you configure)
+3. **This plugin** registers a custom NMEA parser inside Signal K that intercepts those sentences
+4. **The parser** extracts the target's bearing and distance (relative to your boat), then converts that to an absolute latitude/longitude using your boat's GPS position
+5. **Each target** is published into Signal K as a virtual vessel with its own position, speed, and course
+6. **Target positions** are cached locally in a SQLite database (so data is not lost if you lose internet)
+7. **A background connector** batches up cached track points and sends them to the KAHU server using the Avro protocol over TCP
+8. **If the connection drops**, data keeps accumulating locally and is sent when connectivity returns
+
+---
+
+## Installation
+
+```bash
+# From your Signal K server's plugin directory
+npm install radarhub-signalk
+
+# Or clone and link for development
+git clone --recurse-submodules https://github.com/KAHU-radar/radarhub-signalk.git
+cd radarhub-signalk
+npm install
+npm link
+# Then from your Signal K server directory:
+signalk-server --install radarhub-signalk
+```
+
+**Note:** The `data/protocol` folder is a git submodule. If you cloned without `--recurse-submodules`, run:
+```bash
+git submodule update --init
+```
+
+---
+
+## Configuration
+
+Enable the plugin in the Signal K admin UI under **Server > Plugin Config > KAHU Radar Hub**.
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `server` | `crowdsource.kahu.earth` | KAHU server hostname |
+| `port` | `9900` | TCP port for the KAHU server |
+| `api_key` | *(none)* | Your API key for authentication |
+| `min_reconnect_time` | `100` | Minimum delay (ms) before reconnecting after a drop |
+| `max_reconnect_time` | `600` | Maximum delay (ms) between reconnection attempts |
+
+### Prerequisites
+
+- Your radar must be configured for **ARPA tracking** and set to output **$RATTM sentences**
+- Signal K must have a **data connection** to your radar's NMEA output (serial port, TCP, or UDP)
+- Your boat must have a **GPS** providing position data to Signal K
+
+---
+
+## Current Limitations
+
+- Only supports `$RATTM` sentences (not `$RATTL` -- target list sentences)
+- Does not collect AIS data, only radar ARPA targets
+- The protocol is **NOT encrypted** (data is sent in plain text)
+- The protocol is **NOT cryptographically signed** (no tamper protection)
+- Relative bearings (`R`) are not supported -- only true bearings (`T`)
+- The `uuid` npm package is used but not listed in `package.json` (relies on Signal K providing it)
+
+---
+
+## Project Structure
+
+```
+radarhub-signalk/
+├── package.json              # Plugin metadata and dependencies
+├── README.md                 # This file
+├── plugin/
+│   ├── index.js              # Main entry: NMEA parser, Signal K integration
+│   ├── connector.js          # Background TCP connection and track submission
+│   ├── tcpclient.js          # TCP socket client with auto-reconnect
+│   ├── avroclient.js         # Avro serialization/deserialization over TCP
+│   ├── routecache.js         # SQLite local cache for track points
+│   └── utils.js              # Utility helpers
+└── data/protocol/            # Git submodule (radarhub-protocol)
+    ├── proto_avro.json       # Avro schema defining the wire protocol
+    └── migrations/           # SQLite database migrations
+        ├── 0001-create-targets.sql
+        └── 0002-target-indices.sql
+```
+
+---
+
+## Server
+
+An example server written in Python is provided
+[here](https://github.com/KAHU-radar/radarhub-server). This server
+implements the full protocol, but just dumps all received tracks to
+disk in GeoJSON format. It can be used as a simple shore-based VDR
+(Voyage Data Recorder), but mostly serves as an example base for anyone
+wanting to build a more elaborate server-side setup.
+
+---
+
+## Runtime Requirements
+
+- **Signal K Server:** v2.22.1+ (latest stable)
+- **Node.js:** 20.x or later (required by Signal K server v2.22+)
+- **Dependencies:** avro-js, promise-socket, sqlite/sqlite3, uuid
+
+---
+
+## License
+
+ISC

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "kahu-signalk",
+  "version": "0.0.1",
+  "description": "Contribute AIS and ARPA targets from your vessel to crowdsourcing for marine safety!",
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-category-cloud",
+    "signalk-category-nmea-0183",
+    "kahu"
+  ],
+  "signalk-plugin-enabled-by-default": false,
+  "signalk": {
+    "appIcon": "./assets/icons/icon-72x72.png",
+    "displayName": "Kahu - Marine Safety Crowdsourcing"
+  },
+  "main": "plugin/index.js",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Kahu <info@kahu.earth>",
+  "license": "ISC",
+  "dependencies": {
+    "avro-js": "^1.12.0",
+    "promise-socket": "^8.0.0",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
+    "uuid": "^8.1.0"
+  }
+}

package/plugin/avroclient.js

@@ -0,0 +1,39 @@
+const { TCPClient } = require('./tcpclient');
+const avro = require('avro-js');
+
+class AvroClient {
+  constructor({schema, ...props}) {
+    this.schema = schema;
+    this.type = avro.parse(schema);
+    this.tcpClient = new TCPClient(props);
+  }
+
+  async destroy() {
+    await this.tcpClient.destroy();
+  }
+  
+  async ensureConnection() {
+    return await this.tcpClient.ensureConnection();
+  }
+    
+  async send(data) {
+    this.tcpClient.send(this.type.toBuffer(data));
+  }
+
+  async read() {
+    while (true) {
+      const buffer = await this.tcpClient.read();
+      try {
+        const decoded = this.type.fromBuffer(buffer, undefined, true);
+        this.tcpClient.consume(this.type.toBuffer(decoded).length);
+        return decoded;
+      } catch (err) {
+        if (!(err.message == "truncated buffer")) {
+          this.tcpClient.connectionFailure(err, 'Failed to parse Avro document');
+        }
+      }
+    }  
+  }  
+}
+
+module.exports = { AvroClient };

package/plugin/connector.js

@@ -0,0 +1,175 @@
+const fs = require('fs').promises;
+const { delay } = require('./utils');
+const { AvroClient } = require('./avroclient');
+const path = require('path');
+
+// Connector acts as a cooperative thread: When created, it starts an
+// async timeout function immediately
+
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise);
+    console.error("Reason:", reason.stack);
+});
+
+class Connector {
+  constructor({status_function, routecache, plugin_dir, config}) {
+    this.last_stats = null;
+    this.last_status = null;
+    this.status_function = status_function;
+    this.routecache = routecache;
+    this.config = config;
+    this.client = null;
+    this.schema = null;
+    this.callid = 0;
+    this.last_connection = Date(1970, 1, 1);
+    this.last_track_sent = Date(1970, 1, 1);
+    this.cancelled = false;
+    this.schema_file = path.join(
+      plugin_dir,
+      "data",
+      "protocol",
+      "proto_avro.json");
+    this.schema = null;
+    console.error("Connector created");
+    setTimeout(this.main.bind(this), 0);
+  }
+
+  async destroy() {
+    console.error("Connector destroyed");
+    this.cancelled = true;
+    if (this.client) await this.client.destroy();
+    this.client = null;
+  }
+
+  async updateStats() {
+    this.last_stats = await this.routecache.connectionStats();
+    this.updateStatus();
+  }
+  
+  setStatus(status) {
+    this.last_status = status;
+    this.updateStatus();
+  }
+
+  updateStatus() {
+    const status = [];
+    if (this.last_status !== null) status.push(this.last_status);
+    if (this.last_stats !== null) {
+      status.push(`${this.last_stats.unsent_tracks} unsent tracks totalling ${this.last_stats.unsent_datapoints} unsent datapoints`);
+    }
+    this.status_function?.(status.join(", "));
+  }
+  
+  async read(type) {
+    console.error("Connector parsing response");
+
+    const container = await this.client.read();
+    const message = container.Message;
+    const response = message["kahu.Response"].Response;
+    if (response.id != this.callid) {
+      throw "Received response with wrong callid";
+    }
+    const content = response.Response;
+    
+    if (content["kahu.ErrorResponseMessage"] !== undefined) {    
+      throw content.Error.exception;
+    } else if (   (type !== undefined)
+               && (content[type] === undefined)) {
+      throw "Received response for wrong method: expected " + type + " but got " + Object.keys(content)[0];
+    }
+    console.error("Connector response parsed");
+    return container;
+  }
+
+  async login() {
+    while (!this.config.api_key) await delay(500);
+    
+    console.error("Connector logging in");
+
+    await this.client.send({
+      Message: {
+        "kahu.Call": {
+          Call: {
+            id: ++this.callid,
+            Call: {
+              "kahu.LoginMessage": {
+                Login: {
+                  apikey: this.config.api_key
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+    
+    console.error("Send done, gonna parse response\n");
+    const response = await this.read("kahu.LoginResponseMessage");
+    console.error("Response parsed");
+    this.last_connection = new Date();
+  }
+
+  async sendTracks() {
+    console.error("Connector sending tracks");
+    const submit = await this.routecache.retrieve();
+    if (submit === null) return;
+    await this.client.send({
+      Message: {
+        "kahu.Call": {
+          Call: {
+            id: ++this.callid,
+            Call: {
+              "kahu.SubmitMessage": {
+                Submit: submit
+              }
+            }
+          }
+        }
+      }
+    });
+    
+    await this.read("kahu.SubmitResponseMessage");
+    await this.routecache.markAsSent(submit);
+    this.last_track_sent = new Date();
+    console.log("Tracks sent");
+    await this.updateStats();
+  }
+
+  async main() {
+    try {
+      console.error("Connector running client is null: ", (this.client === null));
+
+      this.schema = await fs.readFile(this.schema_file, 'utf8');
+
+      this.client = new AvroClient({
+        schema: this.schema,
+        ip: this.config.server || "crowdsource.kahu.earth",
+        port: this.config.port || 9900,
+        min_reconnect_time: this.config.min_reconnect_time || 100.0,
+        max_reconnect_time: this.config.max_reconnect_time || 6000.0,
+        connect_function: this.login.bind(this),
+        status_function: this.setStatus.bind(this)
+      });
+
+      while (!this.cancelled) {
+        try {
+          console.error("Connector connecting...");
+          await this.client.ensureConnection();
+          if (this.cancelled) break;
+          await this.sendTracks();
+          if (this.cancelled) break;
+          await delay(500);
+        } catch (e) {
+          console.error(e.toString(), " in Connector");
+          console.error(e.stack);
+        }
+      }
+      console.error("Connector exiting");
+    } catch (e) {
+      console.error(e.toString(), " in Connector, exiting");
+      console.error(e.stack);
+    }
+  }
+};
+
+module.exports = { Connector };

package/plugin/index.js

@@ -0,0 +1,165 @@
+const { v4: uuidv4 } = require('uuid');
+const { Routecache } = require("./routecache");
+const { Connector } = require("./connector");
+const path = require('path');
+const fs = require('fs');
+
+let packageDir = __dirname;
+while (packageDir !== path.dirname(packageDir)
+       && !fs.existsSync(path.join(packageDir, 'package.json'))) {
+  packageDir = path.dirname(packageDir);
+}
+
+const nmeaRattmRegex = /\$RATTM,(\d{2}),([\d\.\-]+),([\d\.\-]+),([^,]*),([\d\.\-]+),([\d\.\-]+),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),([^,]*),(..*)\*([A-Fa-f0-9]{2})\s*/;
+
+const deg2rad = (degrees) => degrees * (Math.PI / 180);
+
+const polar2Pos = (ownPos, bearing, distance) => {
+  return {
+    latitude: ownPos.latitude + distance * Math.cos(deg2rad(bearing)) / 60. / 1852.,
+    longitude: ownPos.longitude + distance * Math.sin(deg2rad(bearing)) / Math.cos(deg2rad(ownPos.latitude)) / 60. / 1852.};
+}
+
+module.exports = (app) => {
+
+  const plugin = {
+    id: 'radarhub',
+    name: 'KAHU Radar Hub',
+    start: async (settings, restartPlugin) => {
+      console.log("Started KAHU radar Hub")
+
+      plugin.cache = new Routecache(
+        path.join(packageDir, "data", "protocol", "migrations"),
+        path.join(app.getDataDirPath(), "routecache.sqlite3"));
+      await plugin.cache.init();
+      
+      plugin.connector = new Connector({
+        routecache: plugin.cache,
+        plugin_dir: packageDir,
+        config: settings,
+        status_function: app.setPluginStatus.bind(app)});
+      
+      const now = new Date(1970, 1, 1);
+      plugin.route_updates = Array.from(Array(100)).map(() => now);
+      plugin.route_ids = Array.from(Array(100));
+      
+      app.emitPropertyValue('nmea0183sentenceParser', {
+        sentence: 'TTM',
+        parser: ({ id, sentence, parts, tags }, session) => {
+          if (sentence.startsWith("$RATTL")) {
+          } else if (sentence.startsWith("$RATTM")) {
+            const match = nmeaRattmRegex.exec(sentence);
+
+            if (!match) {
+              console.error("Failed to parse RATTM NMEA sentence: [", sentence, "]");
+              return;
+            }
+            if (match.length - 1 != 14) {
+              console.log("Only parsed ", (match.length - 1), " fields of RATTM NMEA sentence: [", sentence, "]");
+              return;
+            }
+            
+            const target_id = parseInt(match[1]);
+            const target_distance = parseFloat(match[2]);
+            const target_bearing = parseFloat(match[3]);
+            const target_bearing_unit = match[4];
+
+            if (target_bearing_unit === 'R') {
+              console.warn("Relative bearings not yet supported, skipping RATTM sentence");
+              return;
+            }
+            
+            const ownPos = app.getSelfPath("navigation.position")?.value;
+            if (!ownPos) {
+              console.warn("No own-ship position available, skipping RATTM sentence");
+              return;
+            }
+            const targetPos = polar2Pos(ownPos, target_bearing, target_distance);
+            
+            const relative = {
+              position: ownPos,
+              distance: target_distance,
+              bearing: target_bearing,
+              bearing_unit: target_bearing_unit,
+              distance_unit: match[10],
+            }
+
+            const target_speed = parseFloat(match[5]);
+            const target_course = parseFloat(match[6]);
+            const target_course_unit = match[7];
+            // target_distance_closes_point_of_approac: parseInt(match[8]),
+            // target_time_closes_point_of_approac: parseInt(match[9]),
+            const target_name = match[11];
+            const target_status = match[12];
+            
+            const now = new Date();
+            if (now - plugin.route_updates[target_id] > 60000) {
+              plugin.route_updates[target_id] = now;
+              plugin.route_ids[target_id] = uuidv4();
+            }
+            
+            return {
+              context: 'vessels.urn:mrn:signalk:uuid:' + plugin.route_ids[target_id],
+              updates: [
+                {
+                  values: [
+                    { path: 'name',
+                      value: target_name
+                    },
+                    { path: 'navigation.speedOverGround',
+                      value: target_speed
+                    },
+                    { path: 'navigation.courseOverGroundTrue',
+                      value: target_course
+                    },
+                    { path: 'navigation.position',
+                      value: {...targetPos, relative}
+                    },
+                  ]
+                }
+              ]
+            };
+          }
+        }
+      });
+
+      app.streambundle
+        .getBus('navigation.position')
+        .forEach(plugin.updatePosition);
+  
+    },
+    stop: async () => {
+      await plugin.connector?.destroy?.();
+      await plugin.routecache?.destroy?.();
+      console.log("Stopped KAHU radar Hub")
+    },
+    schema: () => {
+      return {
+        properties: {
+          server: {type: "string", default: "crowdsource.kahu.earth"},
+          port: {type: "number", default: 9900},
+          api_key: {type: "string"},
+          min_reconnect_time: {type: "number", default: 100.0},
+          max_reconnect_time: {type: "number", default: 600.0}
+        }
+      };
+    },
+    updatePosition: (pos) => {
+      if (pos.source.sentence != "TTM") return;
+
+      const rest = app.getPath(pos.context);
+      
+      const target_id = pos.context.split("vessels.urn:mrn:signalk:uuid:")[1];
+      
+      plugin.cache.insert({
+        target_id: target_id,
+        position: pos.value,
+        speedOverGround: rest?.navigation?.speedOverGround?.value,
+        courseOverGroundTrue: rest?.navigation?.courseOverGroundTrue?.value,
+        name: rest?.name?.value,
+        });
+    }
+  };
+
+  return plugin;
+};

package/plugin/routecache.js

@@ -0,0 +1,266 @@
+const sqlite3 = require('sqlite3').verbose();
+const sqlite = require('sqlite');
+const fs = require('fs').promises;
+const path = require('path');
+
+class Routecache {
+  constructor(migrations_dir, db_name) {
+    this.db = null;
+    this.migrations_dir = migrations_dir;
+    this.db_name = db_name;
+    console.log("Routecache created for " + db_name + " with migrations " + migrations_dir);
+  }
+
+  async init() {
+    try {
+      await this.openDB();
+      await this.createEmpty();
+      await this.migrate();
+      return;
+    } catch (e) {
+      console.error(e, ". Deleting route cache.");
+      try {
+        await fs.unlink(this.db_name);
+        this.closeDB();
+        throw e;
+      } catch (err) {
+        console.error("Unable to delete route cache: ", this.db_name);
+        throw err;
+      }
+    }
+  }
+
+  async doesTableExist(tableName) {
+    const query = await this.db.all(
+      "SELECT count(*) as count FROM sqlite_master WHERE type='table' AND name=?",
+      [tableName]);
+    return query[0].count > 0;
+  }
+
+  async destroy() {
+    if (this.db != null) await this.db.close();
+    this.db = null;
+  }
+
+  async openDB() {
+    this.db = await sqlite.open({
+      filename: this.db_name,
+      driver: sqlite3.Database
+    });
+  }
+
+  async closeDB() {
+    if (this.db != null) await this.db.close();
+    this.db = null;
+  }
+
+  async createEmpty() {
+    if (await this.doesTableExist("migrations")) return;
+    const res = await this.db.run(`
+        CREATE TABLE IF NOT EXISTS migrations (
+            id integer,
+            name text,
+            applied datetime default current_timestamp
+        )
+    `);
+  }
+
+  async migrate() {
+    const rows = await this.db.all(
+      "SELECT max(id) as maxid FROM migrations");
+    const maxId = rows[0].maxid;
+
+    try {
+      const files = (
+        await fs.readdir(
+          this.migrations_dir, { withFileTypes: true }
+        )
+      ).filter(
+        (file) => file.isFile()
+      ).map(
+        (file) => file.name);
+      files.sort();
+      
+      for (const filename of files) {
+        const migrationId = parseInt(filename, 10);
+        if (migrationId > maxId) {
+          const migrationPath = path.join(this.migrations_dir, filename);
+          await this.runMigration(migrationId, migrationPath);
+        }
+      }
+    } catch (error) {
+        throw new Error(`Unable to process migrations directory: ${error.message}`);
+    }
+  }
+
+  async runMigration(i, name) {
+    console.error("Running migration ", i, ": ", name);
+
+    const sql = await fs.readFile(name, 'utf8');    
+    await this.db.exec(sql);
+    await this.db.run(
+      "insert into migrations (id, name) values (?, ?)",
+      [i, name]);
+  }
+
+  async insert({...props}) {
+    const target_count = await this.db.all(`
+      select count(*) as count from target where uuid = ?;
+    `, [props.target_id]);
+    if (target_count[0].count == 0) {
+      await this.db.run(`
+        insert into target (uuid) values (?);
+      `, [props.target_id]);
+    }
+    const target = await this.db.all(`
+      select target_id from target where uuid = ?;
+    `, [props.target_id]);
+    
+    await this.db.run(`
+      insert into target_position (
+        target_id,
+        target_distance,
+        target_bearing,
+        target_bearing_unit,
+        target_speed,
+        target_course,
+        target_course_unit,
+        target_distance_unit,
+        target_name,
+        target_status,
+        latitude,
+        longitude,
+        target_latitude,
+        target_longitude
+      ) values (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+   `,
+      [target[0].target_id,
+       props.position?.relative?.distance,
+       props.position?.relative?.bearing,
+       props.position?.relative?.bearing_unit,
+       props.speedOverGround,
+       props.courseOverGroundTrue,
+       'T', // target_course_unit
+       props.position?.relative?.distance_unit,
+       props.name,
+       'T', //props.target_status,
+       props.position?.relative?.position?.latitude,
+       props.position?.relative?.position?.longitude,
+       props.position?.latitude,
+       props.position?.longitude]);
+  }
+
+  async connectionStats() {
+    const query1 = await this.db.all(`
+      select
+        count(*) as unsent_datapoints
+      from
+        target_position
+      where       
+        not sent;
+      `);
+    const query2 = await this.db.all(`
+      select
+        count(*) as unsent_tracks
+      from
+        (select distinct
+           target_id
+         from
+           target_position
+         where
+           not sent
+        )
+    `);
+    return {unsent_datapoints: query1[0].unsent_datapoints,
+            unsent_tracks: query2[0].unsent_tracks};
+  }
+  
+  async retrieve() {
+    const query = await this.db.all(`
+      select
+        target.uuid,
+        target_position.timestamp,
+        (strftime('%s', timestamp) +  strftime('%f', timestamp) - strftime('%S', timestamp)) * 1000
+          as timestamp_epoch,
+        target_position.target_latitude,
+        target_position.target_longitude
+      from
+        target_position,
+        target
+      where
+        target_position.target_id = (
+          select
+            target_id
+          from
+            target_position
+          where
+            not sent
+            and target_id in (
+              select
+                target_id
+              from
+                target_position
+              group by 
+                target_id
+              having 
+                count(*) > 1
+            )
+          order by
+            timestamp ASC
+          limit 1)
+        and target.target_id = target_position.target_id
+        and not target_position.sent
+        order by timestamp asc
+        limit 100;
+      `);
+
+    if (!query.length) return null;
+
+    const res = {
+      uuid: {"string": query[0].uuid},
+      route: [],
+      nmea: null,
+      start: query[0].timestamp_epoch};
+
+    let isfirst = true;
+    let start;
+
+    for (const row of query) {
+      res.route.push({
+        lat: row.target_latitude,
+        lon: row.target_longitude,
+        timestamp: row.timestamp_epoch - res.start
+      });
+    }
+
+    return res;
+  }
+
+  async markAsSent(route_message) {
+    const end = route_message.route[route_message.route.length - 1].timestamp + route_message.start;
+
+    const uuid = route_message.uuid.string;
+    
+    const query = await this.db.run(`
+      update
+        target_position
+      set
+        sent = 1
+      where
+        target_id = (select target_id from target where uuid = ?)
+        and timestamp <= datetime(? / 1000, 'unixepoch');
+    `, [uuid, end]);
+    
+    console.error(
+      "Updated "
+        + query.changes
+        + " rows for "
+        + uuid
+        + " @ "
+        + end
+        + ".");
+  }
+}
+
+module.exports = { Routecache };

package/plugin/tcpclient.js

@@ -0,0 +1,155 @@
+const net = require("net");
+const { delay } = require('./utils');
+
+let _PromiseSocket = null;
+async function getPromiseSocket() {
+  if (_PromiseSocket === null) {
+    const { PromiseSocket } = await import('promise-socket');
+    _PromiseSocket = PromiseSocket;
+  }
+  return _PromiseSocket;
+}
+
+class SocketException extends Error {
+  constructor(exc, attempt) {
+    const msg = attempt + ": " + exc.toString();
+    super(msg);
+    this.exc = exc;
+    this.attempt = attempt;
+  }
+}
+
+class TCPClient {
+  constructor({ip, port, min_reconnect_time, max_reconnect_time, connect_function, status_function}) {
+    this.ip = ip;
+    this.port = port;
+    this.reconnect_time = 0;
+    this.min_reconnect_time = min_reconnect_time;
+    this.max_reconnect_time = max_reconnect_time;
+    this.connect_function = connect_function;
+    this.status_function = status_function;
+    this.sock = null;
+    this.reconnect_time;
+    this.cancelled = false;
+    this.buffer = Buffer.alloc(0);
+    this.setStatus("Not yet connected");
+  }
+  
+  async destroy() {
+    this.cancelled = true;
+    this.close();
+  }
+  
+  close() {
+    if (this.sock) {
+      console.error("Deleting socket");
+      this.sock.destroy();
+      this.sock = null;
+    }
+  }
+
+  setStatus(status) {
+    this.status = status;
+    this.status_function?.(status);
+  }
+  
+  connectionFailure(error, attempt) {
+    this.close();
+    this.buffer = Buffer.alloc(0);
+    if (this.reconnect_time == 0) {
+        this.reconnect_time = this.min_reconnect_time;
+    } else if (this.reconnect_time < this.max_reconnect_time) {
+        this.reconnect_time = this.reconnect_time * 2;
+    }
+    const exc = new SocketException(error, attempt);
+    if (error.stack !== undefined) exc.stack = error.stack;
+    this.setStatus(exc.toString());
+    throw exc;
+  }
+
+  async connect() {
+    try {
+      if (this.cancelled) return;
+      console.log("Reconnecting in " + this.reconnect_time + "ms");
+      await delay(this.reconnect_time);
+      if (this.cancelled) return;    
+
+      // If any exception is thrown from inside Connect that isn't from
+      // a ConnectionFailure(), we might have an old socket here that
+      // needs cleanup.
+      this.close();
+
+      const PromiseSocket = await getPromiseSocket();
+      this.sock = new PromiseSocket(new net.Socket());
+      await this.sock.connect(this.port, this.ip);
+
+      this.setStatus("Connected");
+      await this.connect_function?.();
+
+      this.setStatus("Logged in");
+      this.reconnect_time = this.min_reconnect_time;
+    } catch (e) {
+      this.connectionFailure(e, "Unable to connect");
+    }
+  }
+
+  async ensureConnection() {
+    while (!this.cancelled && !this.sock) {
+      try {
+        await this.connect();
+      } catch (e) {
+        console.error(e.toString());
+        console.error(e.stack);
+        if (this.cancelled) throw e;
+      }
+    }
+  }
+
+  async send(data) {    
+    if (!this.sock) {
+        this.connectionFailure("No socket", "Socket disconnected when trying to send");
+    }
+
+    try {
+      await this.sock.write(data);
+    } catch (e) {
+      this.connectionFailure(e, "Send failed");
+    }
+  }
+
+  async waitAndSendInitial(data) {
+    while (!this.cancelled) {
+      await this.ensureConnection();
+      try {
+        await this.send(data);
+        return;
+      } catch (e) {
+        console.error(e.toString());
+        console.error(e.stack);
+      }
+    }
+  }
+
+  async read() {
+    if (this.cancelled) {
+      this.connectionFailure("Cancelled", "Interrupted by thread termination");
+    }
+    try {
+      this.buffer = Buffer.concat([
+        this.buffer,
+        await this.sock.read()]);
+    } catch (e) {
+      this.connectionFailure(e, "Socket error while reading");
+    }
+    return this.buffer;
+  }
+
+  consume(size) {
+    if (this.buffer.length < size) {
+      throw new Error("Not enough data in buffer");
+    }
+    this.buffer = this.buffer.subarray(size);
+  }
+}
+
+module.exports = { TCPClient }

package/plugin/utils.js

@@ -0,0 +1,11 @@
+function delay(ms) {
+  return new Promise((resolve) => {
+    if (ms <= 0) {
+      resolve();
+    } else {
+      setTimeout(resolve, ms)
+    }
+  });
+}
+
+module.exports = { delay };