@marineyachtradar/signalk-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MarineYachtRadar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# MaYaRa Server SignalK Plugin
+
+A native SignalK plugin that connects to a remote [mayara-server](https://github.com/MarineYachtRadar/mayara-server) and exposes its radar(s) via SignalK's Radar API.
+
+## Overview
+
+This plugin acts as a thin proxy layer between SignalK and mayara-server. All radar logic (protocol handling, signal processing) runs on mayara-server - this plugin simply forwards control commands and streams radar data.
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        SignalK Server                           │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │              mayara-server-signalk-plugin                 │  │
+│  │                                                           │  │
+│  │  HTTP Client ──────► RadarProvider ◄────── SpokeForwarder │  │
+│  │      │                    │                     │         │  │
+│  └──────┼────────────────────┼─────────────────────┼─────────┘  │
+│         │    radarApi.register()     binaryStreamManager        │
+│         │                    │                     │            │
+│  ┌──────┼────────────────────┼─────────────────────┼─────────┐  │
+│  │      │        SignalK Radar API v2              │         │  │
+│  │      │  /signalk/v2/api/vessels/self/radars/*   │         │  │
+│  └──────┼──────────────────────────────────────────┼─────────┘  │
+└─────────┼──────────────────────────────────────────┼────────────┘
+          │ HTTP                            WebSocket│
+          ▼                                          ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                        mayara-server                            │
+│         /v2/api/radars/*              /v2/api/radars/*/spokes   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Requirements
+
+- **SignalK Server** >= 3.0.0 (with Radar API support)
+- **mayara-server** running and accessible on the network
+
+## Installation
+
+### From npm (recommended)
+
+```bash
+npm install @marineyachtradar/signalk-plugin
+```
+
+### From source
+
+```bash
+git clone https://github.com/MarineYachtRadar/mayara-server-signalk-plugin
+cd mayara-server-signalk-plugin
+npm install
+npm run build
+npm link
+# In your SignalK server directory:
+npm link @marineyachtradar/signalk-plugin
+```
+
+## Configuration
+
+Enable the plugin in SignalK Admin UI and configure:
+
+| Setting | Description | Default |
+|---------|-------------|---------|
+| **Host** | IP address or hostname of mayara-server | `localhost` |
+| **Port** | HTTP port of mayara-server REST API | `6502` |
+| **Use HTTPS/WSS** | Enable secure connections (requires TLS on mayara-server) | `false` |
+| **Discovery Poll Interval** | How often to poll for new/disconnected radars (seconds) | `10` |
+| **Reconnect Interval** | How often to retry when mayara-server is unreachable (seconds) | `5` |
+
+## Features
+
+- **Multi-radar support**: Automatically discovers and manages all radars connected to mayara-server
+- **Full Radar API**: Implements SignalK's RadarProviderMethods interface
+  - Power control (off/standby/transmit)
+  - Range selection
+  - Gain, sea clutter, and rain clutter adjustment
+  - ARPA target acquisition and tracking
+- **Binary spoke streaming**: Uses SignalK's built-in binaryStreamManager for efficient data delivery
+- **Auto-reconnection**: Handles network disconnections gracefully
+- **Integrated GUI**: Includes the MaYaRa radar display webapp
+
+## API Endpoints
+
+Once configured, the plugin exposes radars at:
+
+- `GET /signalk/v2/api/vessels/self/radars` - List all radars
+- `GET /signalk/v2/api/vessels/self/radars/{id}` - Radar info
+- `GET /signalk/v2/api/vessels/self/radars/{id}/capabilities` - Capability manifest
+- `GET /signalk/v2/api/vessels/self/radars/{id}/state` - Current state
+- `PUT /signalk/v2/api/vessels/self/radars/{id}/controls/{control}` - Set control
+- `GET /signalk/v2/api/vessels/self/radars/{id}/targets` - ARPA targets
+- `WS /signalk/v2/api/vessels/self/radars/{id}/stream` - Binary spoke data
+
+## GUI
+
+The radar display is available at:
+```
+http://your-signalk-server:3000/@marineyachtradar/signalk-plugin/
+```
+
+## Development
+
+```bash
+# Use local mayara-gui instead of npm version
+npm run build -- --local-gui
+
+# Link for development
+npm link
+cd ~/.signalk
+npm link @marineyachtradar/signalk-plugin
+```
+
+## License
+
+Apache-2.0 - See [LICENSE](LICENSE)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md)

package/build.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * Build script for mayara-server-signalk-plugin
+ *
+ * Downloads @marineyachtradar/mayara-gui from npm and copies GUI files to public/
+ *
+ * Usage: node build.js [options]
+ *   --local-gui  Use local mayara-gui instead of npm (for development)
+ *   --pack       Create a .tgz tarball with public/ included (for manual install)
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+
+const args = process.argv.slice(2)
+const useLocalGui = args.includes('--local-gui')
+const createPack = args.includes('--pack')
+
+// Paths (relative to this script's directory)
+const scriptDir = __dirname
+const publicDest = path.join(scriptDir, 'public')
+
+/**
+ * Recursively copy directory contents
+ */
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) {
+    console.error(`Source directory not found: ${src}`)
+    process.exit(1)
+  }
+
+  // Remove destination if it exists
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true })
+  }
+
+  // Create destination directory
+  fs.mkdirSync(dest, { recursive: true })
+
+  // Copy all files and subdirectories
+  const entries = fs.readdirSync(src, { withFileTypes: true })
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else {
+      fs.copyFileSync(srcPath, destPath)
+    }
+  }
+}
+
+/**
+ * Download GUI from npm and copy to public/
+ */
+function setupGuiFromNpm() {
+  console.log('Copying GUI from node_modules...\n')
+
+  // Dependencies should already be installed by npm install
+  // (this script runs as postinstall, so node_modules exists)
+  const guiSource = path.join(scriptDir, 'node_modules', '@marineyachtradar', 'mayara-gui')
+
+  if (!fs.existsSync(guiSource)) {
+    console.error('Error: @marineyachtradar/mayara-gui not found in node_modules')
+    console.error('Make sure it is listed in package.json dependencies')
+    process.exit(1)
+  }
+
+  // Remove old public dir
+  if (fs.existsSync(publicDest)) {
+    fs.rmSync(publicDest, { recursive: true })
+  }
+  fs.mkdirSync(publicDest, { recursive: true })
+
+  // Copy GUI files (exclude package.json, node_modules, etc.)
+  const guiPatterns = [
+    { ext: '.html' },
+    { ext: '.js' },
+    { ext: '.css' },
+    { ext: '.ico' },
+    { ext: '.svg' },
+    { dir: 'assets' },
+    { dir: 'proto' },
+    { dir: 'protobuf' }
+  ]
+
+  const entries = fs.readdirSync(guiSource, { withFileTypes: true })
+  for (const entry of entries) {
+    const srcPath = path.join(guiSource, entry.name)
+    const destPath = path.join(publicDest, entry.name)
+
+    if (entry.isDirectory()) {
+      // Copy known directories
+      if (guiPatterns.some(p => p.dir === entry.name)) {
+        copyDir(srcPath, destPath)
+      }
+    } else {
+      // Copy files matching extensions
+      if (guiPatterns.some(p => p.ext && entry.name.endsWith(p.ext))) {
+        fs.copyFileSync(srcPath, destPath)
+      }
+    }
+  }
+
+  const fileCount = fs.readdirSync(publicDest, { recursive: true }).length
+  console.log(`Copied ${fileCount} GUI files to public/\n`)
+}
+
+/**
+ * Copy GUI from local sibling directory (for development)
+ */
+function setupGuiFromLocal() {
+  const localGuiPath = path.join(scriptDir, '..', 'mayara-gui')
+  console.log(`Copying GUI from local ${localGuiPath}...\n`)
+
+  // Remove old public dir
+  if (fs.existsSync(publicDest)) {
+    fs.rmSync(publicDest, { recursive: true })
+  }
+  fs.mkdirSync(publicDest, { recursive: true })
+
+  // Copy GUI files (exclude package.json, node_modules, .git, etc.)
+  const guiPatterns = [
+    { ext: '.html' },
+    { ext: '.js' },
+    { ext: '.css' },
+    { ext: '.ico' },
+    { ext: '.svg' },
+    { dir: 'assets' },
+    { dir: 'proto' },
+    { dir: 'protobuf' }
+  ]
+
+  const entries = fs.readdirSync(localGuiPath, { withFileTypes: true })
+  for (const entry of entries) {
+    const srcPath = path.join(localGuiPath, entry.name)
+    const destPath = path.join(publicDest, entry.name)
+
+    if (entry.isDirectory()) {
+      // Copy known directories
+      if (guiPatterns.some(p => p.dir === entry.name)) {
+        copyDir(srcPath, destPath)
+      }
+    } else {
+      // Copy files matching extensions
+      if (guiPatterns.some(p => p.ext && entry.name.endsWith(p.ext))) {
+        fs.copyFileSync(srcPath, destPath)
+      }
+    }
+  }
+
+  const fileCount = fs.readdirSync(publicDest, { recursive: true }).length
+  console.log(`Copied ${fileCount} files from local mayara-gui/ to public/\n`)
+}
+
+function main() {
+  console.log('=== MaYaRa SignalK Plugin Build ===\n')
+
+  // Get GUI assets
+  console.log('Setting up GUI assets...\n')
+  if (useLocalGui) {
+    setupGuiFromLocal()
+  } else {
+    setupGuiFromNpm()
+  }
+
+  // Create tarball if --pack flag is set
+  if (createPack) {
+    console.log('Creating tarball with public/ included...\n')
+
+    // Temporarily remove public/ from .npmignore
+    const npmignorePath = path.join(scriptDir, '.npmignore')
+    const npmignoreContent = fs.readFileSync(npmignorePath, 'utf8')
+    const npmignoreWithoutPublic = npmignoreContent.replace(/^public\/\n?/m, '')
+    fs.writeFileSync(npmignorePath, npmignoreWithoutPublic)
+
+    // Also temporarily add public/ to files in package.json
+    const pkgPath = path.join(scriptDir, 'package.json')
+    const pkgContent = fs.readFileSync(pkgPath, 'utf8')
+    const pkg = JSON.parse(pkgContent)
+    const originalFiles = [...pkg.files]
+    pkg.files.push('public/**/*')
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+
+    try {
+      // Run npm pack
+      execSync('npm pack', { stdio: 'inherit', cwd: scriptDir })
+      console.log('\nTarball created successfully!')
+    } finally {
+      // Restore .npmignore
+      fs.writeFileSync(npmignorePath, npmignoreContent)
+      // Restore package.json
+      pkg.files = originalFiles
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+    }
+  }
+
+  console.log('\n=== Build complete ===')
+}
+
+main()

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@marineyachtradar/signalk-plugin",
+  "version": "0.1.0",
+  "description": "MaYaRa Radar - Connect SignalK to mayara-server",
+  "main": "plugin/index.js",
+  "scripts": {
+    "build": "node build.js",
+    "postinstall": "node build.js"
+  },
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-webapp",
+    "signalk-category-instruments",
+    "radar",
+    "marine",
+    "mayara"
+  ],
+  "signalk": {
+    "displayName": "MaYaRa Radar (Server)",
+    "appIcon": "assets/mayara_logo.png",
+    "webapp": {
+      "name": "MaYaRa Radar",
+      "description": "Marine radar display connected to mayara-server",
+      "location": "/plugins/@marineyachtradar/signalk-plugin/"
+    }
+  },
+  "files": [
+    "plugin/**/*",
+    "build.js"
+  ],
+  "engines": {
+    "signalk": ">=2.0.0"
+  },
+  "dependencies": {
+    "@marineyachtradar/mayara-gui": "^0.6.0",
+    "ws": "^8.14.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarineYachtRadar/mayara-server-signalk-plugin"
+  },
+  "author": "MarineYachtRadar Contributors",
+  "license": "Apache-2.0"
+}

package/plugin/index.js

@@ -0,0 +1,306 @@
+/**
+ * MaYaRa Radar SignalK Plugin
+ *
+ * Connects to a remote mayara-server and exposes its radar(s) via SignalK's Radar API.
+ * The plugin acts as a thin proxy layer - all radar logic runs on mayara-server.
+ */
+
+const MayaraClient = require('./mayara-client')
+const createRadarProvider = require('./radar-provider')
+const SpokeForwarder = require('./spoke-forwarder')
+
+module.exports = function (app) {
+  let client = null
+  let provider = null
+  let spokeForwarders = new Map() // radarId -> SpokeForwarder
+  let discoveryInterval = null
+  let reconnectInterval = null
+  let isConnected = false
+  let knownRadars = new Set()
+
+  const plugin = {
+    id: 'mayara-server-signalk-plugin',
+    name: 'MaYaRa Radar (Server)',
+    description: 'Connect SignalK to mayara-server for multi-brand marine radar integration',
+
+    schema: () => ({
+      type: 'object',
+      title: 'MaYaRa Server Connection',
+      required: ['host', 'port'],
+      properties: {
+        host: {
+          type: 'string',
+          title: 'mayara-server Host',
+          description: 'IP address or hostname of mayara-server',
+          default: 'localhost'
+        },
+        port: {
+          type: 'number',
+          title: 'mayara-server Port',
+          description: 'HTTP port of mayara-server REST API',
+          default: 6502,
+          minimum: 1,
+          maximum: 65535
+        },
+        secure: {
+          type: 'boolean',
+          title: 'Use HTTPS/WSS',
+          description: 'Use secure connections (requires TLS on mayara-server)',
+          default: false
+        },
+        discoveryPollInterval: {
+          type: 'number',
+          title: 'Discovery Poll Interval (seconds)',
+          description: 'How often to poll for new/disconnected radars',
+          default: 10,
+          minimum: 5,
+          maximum: 60
+        },
+        reconnectInterval: {
+          type: 'number',
+          title: 'Reconnect Interval (seconds)',
+          description: 'How often to retry connection when mayara-server is unreachable',
+          default: 5,
+          minimum: 1,
+          maximum: 30
+        }
+      }
+    }),
+
+    start: function (settings) {
+      app.debug('Starting mayara-server-signalk-plugin')
+
+      // Initialize client to mayara-server
+      client = new MayaraClient({
+        host: settings.host || 'localhost',
+        port: settings.port || 6502,
+        secure: settings.secure || false,
+        debug: app.debug.bind(app)
+      })
+
+      // Create RadarProvider implementation
+      provider = createRadarProvider(client, app)
+
+      // Check if radar API is available
+      if (!app.radarApi) {
+        app.setPluginError('SignalK Radar API not available (requires SignalK >= 2.0.0)')
+        return
+      }
+
+      // Register with SignalK Radar API
+      try {
+        app.radarApi.register(plugin.id, {
+          name: plugin.name,
+          methods: provider
+        })
+        app.debug('Registered as radar provider')
+      } catch (err) {
+        app.setPluginError(`Failed to register radar provider: ${err.message}`)
+        return
+      }
+
+      // Start connection and discovery
+      connectAndDiscover(settings)
+    },
+
+    stop: function () {
+      app.debug('Stopping mayara-server-signalk-plugin')
+
+      // Unregister from radar API
+      if (app.radarApi) {
+        try {
+          app.radarApi.unRegister(plugin.id)
+        } catch (err) {
+          app.debug(`Error unregistering: ${err.message}`)
+        }
+      }
+
+      // Clear intervals
+      if (discoveryInterval) {
+        clearInterval(discoveryInterval)
+        discoveryInterval = null
+      }
+      if (reconnectInterval) {
+        clearInterval(reconnectInterval)
+        reconnectInterval = null
+      }
+
+      // Stop all spoke forwarders
+      for (const forwarder of spokeForwarders.values()) {
+        forwarder.stop()
+      }
+      spokeForwarders.clear()
+      knownRadars.clear()
+
+      // Close client
+      if (client) {
+        client.close()
+        client = null
+      }
+
+      isConnected = false
+      app.setPluginStatus('Stopped')
+    },
+
+    registerWithRouter: function (router) {
+      // Health check endpoint
+      router.get('/status', (req, res) => {
+        res.json({
+          connected: isConnected,
+          radars: Array.from(knownRadars),
+          spokeForwarders: Array.from(spokeForwarders.keys()).map(id => ({
+            radarId: id,
+            connected: spokeForwarders.get(id)?.isConnected() || false
+          }))
+        })
+      })
+    }
+  }
+
+  async function connectAndDiscover(settings) {
+    try {
+      // Try to connect to mayara-server
+      const radars = await client.getRadars()
+      isConnected = true
+
+      const radarIds = Object.keys(radars)
+      app.setPluginStatus(`Connected - ${radarIds.length} radar(s) found`)
+
+      // Update known radars and start spoke forwarders
+      await updateRadars(radarIds, settings)
+
+      // Start discovery polling
+      const pollMs = (settings.discoveryPollInterval || 10) * 1000
+      discoveryInterval = setInterval(() => {
+        pollForRadarChanges(settings)
+      }, pollMs)
+
+    } catch (err) {
+      isConnected = false
+      app.setPluginError(`Cannot connect to mayara-server: ${err.message}`)
+
+      // Schedule reconnect
+      const reconnectMs = (settings.reconnectInterval || 5) * 1000
+      reconnectInterval = setInterval(async () => {
+        try {
+          const radars = await client.getRadars()
+          isConnected = true
+
+          const radarIds = Object.keys(radars)
+          app.setPluginStatus(`Connected - ${radarIds.length} radar(s) found`)
+
+          // Clear reconnect timer
+          clearInterval(reconnectInterval)
+          reconnectInterval = null
+
+          // Update radars
+          await updateRadars(radarIds, settings)
+
+          // Start discovery polling
+          const pollMs = (settings.discoveryPollInterval || 10) * 1000
+          discoveryInterval = setInterval(() => {
+            pollForRadarChanges(settings)
+          }, pollMs)
+
+        } catch (e) {
+          // Still disconnected, keep trying
+          app.debug(`Reconnect failed: ${e.message}`)
+        }
+      }, reconnectMs)
+    }
+  }
+
+  async function updateRadars(radarIds, settings) {
+    const currentIds = new Set(radarIds)
+
+    // Add new radars
+    for (const radarId of currentIds) {
+      if (!knownRadars.has(radarId)) {
+        app.debug(`New radar discovered: ${radarId}`)
+        knownRadars.add(radarId)
+
+        // Start spoke forwarder for this radar
+        if (app.binaryStreamManager) {
+          const forwarder = new SpokeForwarder({
+            radarId: radarId,
+            url: client.getSpokeStreamUrl(radarId),
+            binaryStreamManager: app.binaryStreamManager,
+            debug: app.debug.bind(app),
+            reconnectInterval: (settings.reconnectInterval || 5) * 1000
+          })
+          spokeForwarders.set(radarId, forwarder)
+          forwarder.start()
+        } else {
+          app.debug('binaryStreamManager not available - spoke streaming disabled')
+        }
+      }
+    }
+
+    // Remove disconnected radars
+    for (const radarId of knownRadars) {
+      if (!currentIds.has(radarId)) {
+        app.debug(`Radar disconnected: ${radarId}`)
+        knownRadars.delete(radarId)
+
+        // Stop spoke forwarder
+        const forwarder = spokeForwarders.get(radarId)
+        if (forwarder) {
+          forwarder.stop()
+          spokeForwarders.delete(radarId)
+        }
+      }
+    }
+  }
+
+  async function pollForRadarChanges(settings) {
+    try {
+      const radars = await client.getRadars()
+      const radarIds = Object.keys(radars)
+
+      await updateRadars(radarIds, settings)
+
+      app.setPluginStatus(`Connected - ${radarIds.length} radar(s)`)
+
+    } catch (err) {
+      // Lost connection
+      isConnected = false
+      app.setPluginError(`Lost connection: ${err.message}`)
+
+      // Stop discovery polling
+      if (discoveryInterval) {
+        clearInterval(discoveryInterval)
+        discoveryInterval = null
+      }
+
+      // Start reconnect timer
+      const reconnectMs = (settings.reconnectInterval || 5) * 1000
+      reconnectInterval = setInterval(async () => {
+        try {
+          const radars = await client.getRadars()
+          isConnected = true
+
+          const radarIds = Object.keys(radars)
+          app.setPluginStatus(`Connected - ${radarIds.length} radar(s) found`)
+
+          // Clear reconnect timer
+          clearInterval(reconnectInterval)
+          reconnectInterval = null
+
+          // Update radars
+          await updateRadars(radarIds, settings)
+
+          // Restart discovery polling
+          const pollMs = (settings.discoveryPollInterval || 10) * 1000
+          discoveryInterval = setInterval(() => {
+            pollForRadarChanges(settings)
+          }, pollMs)
+
+        } catch (e) {
+          // Still disconnected
+        }
+      }, reconnectMs)
+    }
+  }
+
+  return plugin
+}

package/plugin/mayara-client.js

@@ -0,0 +1,197 @@
+/**
+ * HTTP client for mayara-server REST API
+ *
+ * Provides methods to communicate with mayara-server's /v2/api/radars/* endpoints.
+ */
+
+const http = require('http')
+const https = require('https')
+
+class MayaraClient {
+  constructor({ host, port, secure = false, timeout = 10000, debug = () => {} }) {
+    this.host = host
+    this.port = port
+    this.secure = secure
+    this.timeout = timeout
+    this.debug = debug
+    this.baseUrl = `${secure ? 'https' : 'http'}://${host}:${port}`
+  }
+
+  /**
+   * Make an HTTP request to mayara-server
+   * @param {string} method - HTTP method (GET, PUT, POST, DELETE)
+   * @param {string} path - API path (e.g., /v2/api/radars)
+   * @param {object|null} body - Request body (for PUT/POST)
+   * @returns {Promise<any>} - Parsed JSON response
+   */
+  async request(method, path, body = null) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: this.host,
+        port: this.port,
+        path: path,
+        method: method,
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json'
+        },
+        timeout: this.timeout
+      }
+
+      const transport = this.secure ? https : http
+
+      const req = transport.request(options, (res) => {
+        let data = ''
+        res.on('data', chunk => data += chunk)
+        res.on('end', () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(data ? JSON.parse(data) : null)
+            } catch (e) {
+              resolve(data)
+            }
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`))
+          }
+        })
+      })
+
+      req.on('error', reject)
+      req.on('timeout', () => {
+        req.destroy()
+        reject(new Error('Request timeout'))
+      })
+
+      if (body) {
+        req.write(JSON.stringify(body))
+      }
+      req.end()
+    })
+  }
+
+  // ============================================
+  // Radar Discovery
+  // ============================================
+
+  /**
+   * Get list of all radars
+   * @returns {Promise<object>} - Object keyed by radar ID
+   */
+  async getRadars() {
+    return this.request('GET', '/v2/api/radars')
+  }
+
+  // ============================================
+  // Capabilities & State
+  // ============================================
+
+  /**
+   * Get capability manifest for a radar
+   * @param {string} radarId - The radar ID
+   * @returns {Promise<object>} - CapabilityManifest
+   */
+  async getCapabilities(radarId) {
+    return this.request('GET', `/v2/api/radars/${radarId}/capabilities`)
+  }
+
+  /**
+   * Get current state for a radar
+   * @param {string} radarId - The radar ID
+   * @returns {Promise<object>} - RadarState
+   */
+  async getState(radarId) {
+    return this.request('GET', `/v2/api/radars/${radarId}/state`)
+  }
+
+  // ============================================
+  // Controls
+  // ============================================
+
+  /**
+   * Set a single control value
+   * @param {string} radarId - The radar ID
+   * @param {string} controlId - The control ID (e.g., "power", "gain")
+   * @param {any} value - The value to set
+   * @returns {Promise<object>} - Result
+   */
+  async setControl(radarId, controlId, value) {
+    return this.request('PUT', `/v2/api/radars/${radarId}/controls/${controlId}`, { value })
+  }
+
+  /**
+   * Set multiple controls at once
+   * @param {string} radarId - The radar ID
+   * @param {object} controls - Object with controlId: value pairs
+   * @returns {Promise<object>} - Result
+   */
+  async setControls(radarId, controls) {
+    return this.request('PUT', `/v2/api/radars/${radarId}/controls`, controls)
+  }
+
+  // ============================================
+  // ARPA Targets
+  // ============================================
+
+  /**
+   * Get all tracked ARPA targets
+   * @param {string} radarId - The radar ID
+   * @returns {Promise<object>} - TargetListResponse
+   */
+  async getTargets(radarId) {
+    return this.request('GET', `/v2/api/radars/${radarId}/targets`)
+  }
+
+  /**
+   * Manually acquire a target at bearing/distance
+   * @param {string} radarId - The radar ID
+   * @param {number} bearing - Bearing in degrees (0-360)
+   * @param {number} distance - Distance in meters
+   * @returns {Promise<object>} - Result with targetId
+   */
+  async acquireTarget(radarId, bearing, distance) {
+    return this.request('POST', `/v2/api/radars/${radarId}/targets`, { bearing, distance })
+  }
+
+  /**
+   * Cancel tracking of a target
+   * @param {string} radarId - The radar ID
+   * @param {number} targetId - The target ID to cancel
+   * @returns {Promise<object>} - Result
+   */
+  async cancelTarget(radarId, targetId) {
+    return this.request('DELETE', `/v2/api/radars/${radarId}/targets/${targetId}`)
+  }
+
+  // ============================================
+  // WebSocket URLs
+  // ============================================
+
+  /**
+   * Get WebSocket URL for spoke streaming
+   * @param {string} radarId - The radar ID
+   * @returns {string} - WebSocket URL
+   */
+  getSpokeStreamUrl(radarId) {
+    const wsProtocol = this.secure ? 'wss' : 'ws'
+    return `${wsProtocol}://${this.host}:${this.port}/v2/api/radars/${radarId}/spokes`
+  }
+
+  /**
+   * Get WebSocket URL for target streaming
+   * @param {string} radarId - The radar ID
+   * @returns {string} - WebSocket URL
+   */
+  getTargetStreamUrl(radarId) {
+    const wsProtocol = this.secure ? 'wss' : 'ws'
+    return `${wsProtocol}://${this.host}:${this.port}/v2/api/radars/${radarId}/targets/stream`
+  }
+
+  /**
+   * Close any persistent connections (none for HTTP client)
+   */
+  close() {
+    // No persistent connections to close for HTTP client
+  }
+}
+
+module.exports = MayaraClient

package/plugin/radar-provider.js

@@ -0,0 +1,308 @@
+/**
+ * RadarProvider implementation for SignalK Radar API
+ *
+ * Implements RadarProviderMethods interface by proxying calls to mayara-server.
+ * See: signalk-server/packages/server-api/src/radarapi.ts
+ */
+
+/**
+ * Create a RadarProvider that proxies to mayara-server
+ * @param {MayaraClient} client - The mayara-server HTTP client
+ * @param {object} app - SignalK app object
+ * @returns {object} - RadarProviderMethods implementation
+ */
+function createRadarProvider(client, app) {
+  const debug = app.debug.bind(app)
+
+  return {
+    // ============================================
+    // Required Methods
+    // ============================================
+
+    /**
+     * Get list of radar IDs this provider manages
+     * @returns {Promise<string[]>} - Array of radar IDs
+     */
+    async getRadars() {
+      try {
+        const radars = await client.getRadars()
+        // mayara-server returns object keyed by ID
+        return Object.keys(radars)
+      } catch (err) {
+        debug(`getRadars error: ${err.message}`)
+        return []
+      }
+    },
+
+    /**
+     * Get detailed info for a specific radar
+     * @param {string} radarId - The radar ID
+     * @returns {Promise<RadarInfo|null>} - Radar info or null
+     */
+    async getRadarInfo(radarId) {
+      try {
+        const state = await client.getState(radarId)
+        if (!state) return null
+
+        const capabilities = await client.getCapabilities(radarId)
+
+        // Build RadarInfo from state and capabilities
+        return {
+          id: radarId,
+          name: capabilities?.model
+            ? `${capabilities.make || ''} ${capabilities.model}`.trim()
+            : radarId,
+          brand: capabilities?.make || 'Unknown',
+          status: state.status || 'standby',
+          spokesPerRevolution: capabilities?.characteristics?.spokesPerRevolution || 2048,
+          maxSpokeLen: capabilities?.characteristics?.maxSpokeLength || 512,
+          range: state.controls?.range || 1852,
+          controls: {
+            gain: state.controls?.gain || { auto: true, value: 50 },
+            sea: state.controls?.sea || { auto: true, value: 50 },
+            rain: state.controls?.rain || { value: 0 }
+          },
+          // streamUrl undefined = use SignalK's built-in stream endpoint
+          streamUrl: undefined
+        }
+      } catch (err) {
+        debug(`getRadarInfo error for ${radarId}: ${err.message}`)
+        return null
+      }
+    },
+
+    // ============================================
+    // Capability and State Methods
+    // ============================================
+
+    /**
+     * Get capability manifest for a radar
+     * @param {string} radarId - The radar ID
+     * @returns {Promise<CapabilityManifest|null>}
+     */
+    async getCapabilities(radarId) {
+      try {
+        return await client.getCapabilities(radarId)
+      } catch (err) {
+        debug(`getCapabilities error for ${radarId}: ${err.message}`)
+        return null
+      }
+    },
+
+    /**
+     * Get current radar state
+     * @param {string} radarId - The radar ID
+     * @returns {Promise<RadarState|null>}
+     */
+    async getState(radarId) {
+      try {
+        return await client.getState(radarId)
+      } catch (err) {
+        debug(`getState error for ${radarId}: ${err.message}`)
+        return null
+      }
+    },
+
+    /**
+     * Get a single control value
+     * @param {string} radarId - The radar ID
+     * @param {string} controlId - The control ID
+     * @returns {Promise<any|null>}
+     */
+    async getControl(radarId, controlId) {
+      try {
+        const state = await client.getState(radarId)
+        return state?.controls?.[controlId] ?? null
+      } catch (err) {
+        debug(`getControl error for ${radarId}/${controlId}: ${err.message}`)
+        return null
+      }
+    },
+
+    // ============================================
+    // Control Methods
+    // ============================================
+
+    /**
+     * Set radar power state
+     * @param {string} radarId - The radar ID
+     * @param {string} state - Power state (off, standby, transmit)
+     * @returns {Promise<boolean>}
+     */
+    async setPower(radarId, state) {
+      try {
+        await client.setControl(radarId, 'power', state)
+        return true
+      } catch (err) {
+        debug(`setPower error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    /**
+     * Set radar range
+     * @param {string} radarId - The radar ID
+     * @param {number} range - Range in meters
+     * @returns {Promise<boolean>}
+     */
+    async setRange(radarId, range) {
+      try {
+        await client.setControl(radarId, 'range', range)
+        return true
+      } catch (err) {
+        debug(`setRange error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    /**
+     * Set radar gain
+     * @param {string} radarId - The radar ID
+     * @param {object} gain - { auto: boolean, value?: number }
+     * @returns {Promise<boolean>}
+     */
+    async setGain(radarId, gain) {
+      try {
+        const value = {
+          mode: gain.auto ? 'auto' : 'manual',
+          value: gain.value ?? 50
+        }
+        await client.setControl(radarId, 'gain', value)
+        return true
+      } catch (err) {
+        debug(`setGain error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    /**
+     * Set sea clutter
+     * @param {string} radarId - The radar ID
+     * @param {object} sea - { auto: boolean, value?: number }
+     * @returns {Promise<boolean>}
+     */
+    async setSea(radarId, sea) {
+      try {
+        const value = {
+          mode: sea.auto ? 'auto' : 'manual',
+          value: sea.value ?? 50
+        }
+        await client.setControl(radarId, 'sea', value)
+        return true
+      } catch (err) {
+        debug(`setSea error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    /**
+     * Set rain clutter
+     * @param {string} radarId - The radar ID
+     * @param {object} rain - { auto: boolean, value?: number }
+     * @returns {Promise<boolean>}
+     */
+    async setRain(radarId, rain) {
+      try {
+        const value = {
+          mode: rain.auto ? 'auto' : 'manual',
+          value: rain.value ?? 0
+        }
+        await client.setControl(radarId, 'rain', value)
+        return true
+      } catch (err) {
+        debug(`setRain error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    /**
+     * Set a single control value
+     * @param {string} radarId - The radar ID
+     * @param {string} controlId - The control ID
+     * @param {any} value - The value to set
+     * @returns {Promise<{success: boolean, error?: string}>}
+     */
+    async setControl(radarId, controlId, value) {
+      try {
+        await client.setControl(radarId, controlId, value)
+        return { success: true }
+      } catch (err) {
+        debug(`setControl error for ${radarId}/${controlId}: ${err.message}`)
+        return { success: false, error: err.message }
+      }
+    },
+
+    /**
+     * Set multiple controls at once
+     * @param {string} radarId - The radar ID
+     * @param {object} controls - Partial controls to update
+     * @returns {Promise<boolean>}
+     */
+    async setControls(radarId, controls) {
+      try {
+        await client.setControls(radarId, controls)
+        return true
+      } catch (err) {
+        debug(`setControls error for ${radarId}: ${err.message}`)
+        return false
+      }
+    },
+
+    // ============================================
+    // ARPA Target Methods
+    // ============================================
+
+    /**
+     * Get all tracked ARPA targets
+     * @param {string} radarId - The radar ID
+     * @returns {Promise<TargetListResponse|null>}
+     */
+    async getTargets(radarId) {
+      try {
+        return await client.getTargets(radarId)
+      } catch (err) {
+        debug(`getTargets error for ${radarId}: ${err.message}`)
+        return null
+      }
+    },
+
+    /**
+     * Manually acquire a target
+     * @param {string} radarId - The radar ID
+     * @param {number} bearing - Bearing in degrees (0-360)
+     * @param {number} distance - Distance in meters
+     * @returns {Promise<{success: boolean, targetId?: number, error?: string}>}
+     */
+    async acquireTarget(radarId, bearing, distance) {
+      try {
+        const result = await client.acquireTarget(radarId, bearing, distance)
+        return { success: true, targetId: result.targetId }
+      } catch (err) {
+        debug(`acquireTarget error for ${radarId}: ${err.message}`)
+        return { success: false, error: err.message }
+      }
+    },
+
+    /**
+     * Cancel tracking of a target
+     * @param {string} radarId - The radar ID
+     * @param {number} targetId - The target ID
+     * @returns {Promise<boolean>}
+     */
+    async cancelTarget(radarId, targetId) {
+      try {
+        await client.cancelTarget(radarId, targetId)
+        return true
+      } catch (err) {
+        debug(`cancelTarget error for ${radarId}/${targetId}: ${err.message}`)
+        return false
+      }
+    }
+
+    // Note: handleStreamConnection is NOT implemented here.
+    // Spoke streaming is handled by SpokeForwarder which uses
+    // app.binaryStreamManager.emitData() directly.
+  }
+}
+
+module.exports = createRadarProvider

package/plugin/spoke-forwarder.js

@@ -0,0 +1,143 @@
+/**
+ * SpokeForwarder - WebSocket client that forwards spoke data to SignalK's binaryStreamManager
+ *
+ * Connects to mayara-server's spoke WebSocket endpoint and forwards binary data
+ * to SignalK's built-in binary stream infrastructure.
+ *
+ * SignalK clients connect to /signalk/v2/api/vessels/self/radars/{id}/stream
+ * and receive the forwarded data automatically.
+ */
+
+const WebSocket = require('ws')
+
+class SpokeForwarder {
+  /**
+   * Create a SpokeForwarder
+   * @param {object} options - Configuration options
+   * @param {string} options.radarId - The radar ID
+   * @param {string} options.url - WebSocket URL for mayara-server spoke stream
+   * @param {object} options.binaryStreamManager - SignalK's binaryStreamManager
+   * @param {function} options.debug - Debug logging function
+   * @param {number} options.reconnectInterval - Reconnect interval in ms (default: 5000)
+   */
+  constructor({ radarId, url, binaryStreamManager, debug, reconnectInterval = 5000 }) {
+    this.radarId = radarId
+    this.url = url
+    this.binaryStreamManager = binaryStreamManager
+    this.debug = debug || (() => {})
+    this.reconnectInterval = reconnectInterval
+
+    this.ws = null
+    this.reconnectTimer = null
+    this.closed = false
+    this.connected = false
+
+    // Stream ID for binaryStreamManager (matches SignalK radar stream pattern)
+    this.streamId = `radars/${radarId}`
+  }
+
+  /**
+   * Start the forwarder - connect to mayara-server
+   */
+  start() {
+    if (this.closed) return
+    this.connect()
+  }
+
+  /**
+   * Connect to mayara-server spoke WebSocket
+   */
+  connect() {
+    if (this.closed) return
+
+    this.debug(`Connecting to spoke stream: ${this.url}`)
+
+    try {
+      this.ws = new WebSocket(this.url)
+      this.ws.binaryType = 'arraybuffer'
+
+      this.ws.on('open', () => {
+        this.connected = true
+        this.debug(`Connected to spoke stream for ${this.radarId}`)
+      })
+
+      this.ws.on('message', (data) => {
+        // Forward binary spoke data to SignalK's binaryStreamManager
+        if (this.binaryStreamManager && data instanceof ArrayBuffer) {
+          const buffer = Buffer.from(data)
+          this.binaryStreamManager.emitData(this.streamId, buffer)
+        } else if (this.binaryStreamManager && Buffer.isBuffer(data)) {
+          this.binaryStreamManager.emitData(this.streamId, data)
+        }
+      })
+
+      this.ws.on('error', (err) => {
+        this.debug(`Spoke stream error for ${this.radarId}: ${err.message}`)
+      })
+
+      this.ws.on('close', (code, reason) => {
+        this.connected = false
+        this.debug(`Spoke stream closed for ${this.radarId}: ${code} ${reason}`)
+
+        if (!this.closed) {
+          this.scheduleReconnect()
+        }
+      })
+    } catch (err) {
+      this.debug(`Failed to connect to spoke stream for ${this.radarId}: ${err.message}`)
+      if (!this.closed) {
+        this.scheduleReconnect()
+      }
+    }
+  }
+
+  /**
+   * Schedule a reconnection attempt
+   */
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return
+
+    this.debug(`Scheduling reconnect for ${this.radarId} in ${this.reconnectInterval}ms`)
+
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      if (!this.closed) {
+        this.connect()
+      }
+    }, this.reconnectInterval)
+  }
+
+  /**
+   * Check if the forwarder is connected
+   * @returns {boolean}
+   */
+  isConnected() {
+    return this.connected
+  }
+
+  /**
+   * Stop the forwarder and close the WebSocket
+   */
+  stop() {
+    this.closed = true
+
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+
+    if (this.ws) {
+      try {
+        this.ws.close()
+      } catch (err) {
+        // Ignore close errors
+      }
+      this.ws = null
+    }
+
+    this.connected = false
+    this.debug(`Stopped spoke forwarder for ${this.radarId}`)
+  }
+}
+
+module.exports = SpokeForwarder