thatSFguy
diff --git a/‎README.md‎
Lines changed: 156 additions & 41 deletions b/‎README.md‎
Lines changed: 156 additions & 41 deletions
diff --git a/‎index.html‎
Lines changed: 7 additions & 0 deletions b/‎index.html‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎js/app.js‎
Lines changed: 78 additions & 49 deletions b/‎js/app.js‎
Lines changed: 78 additions & 49 deletions
diff --git a/‎js/hdlc.js‎
Lines changed: 86 additions & 0 deletions b/‎js/hdlc.js‎
Lines changed: 86 additions & 0 deletions
diff --git a/‎js/rnsd-interface.js‎
Lines changed: 101 additions & 0 deletions b/‎js/rnsd-interface.js‎
Lines changed: 101 additions & 0 deletions
@@ -28,9 +28,16 @@ <h2>Connect</h2>
     <span><span class="status-dot" id="conn-dot"></span><span id="conn-text">Disconnected</span></span>
     <button id="btn-connect-ble">Connect (BLE)</button>
     <button id="btn-connect-serial" class="secondary">Connect (Serial)</button>
+    <button id="btn-connect-ws" class="secondary">Connect (WebSocket)</button>
     <button id="btn-disconnect" class="secondary hidden">Disconnect</button>
     <span id="radio-status" class="status-off"></span>
   </div>
+  <div class="row" id="ws-url-row" style="margin-top: 8px;">
+    <div class="field wide">
+      <label>WebSocket URL (for TCP-via-bridge)</label>
+      <input id="ws-url" type="text" value="ws://localhost:7878" placeholder="ws://localhost:7878">
+    </div>
+  </div>
 </div>
 
 <!-- Identity panel -->
 
@@ -4,6 +4,7 @@
 
 import { encode as msgpackEncode } from '@msgpack/msgpack';
 import { RNode } from './rnode.js';
+import { RnsdInterface } from './rnsd-interface.js';
 import { toHex } from './kiss.js';
 import { Identity, computeDestinationHash, computeNameHash } from './identity.js';
 import { parsePacket, buildPacket, PACKET_ANNOUNCE, PACKET_DATA, PACKET_LINKREQ, PACKET_PROOF, DEST_SINGLE, DEST_LINK, HEADER_1, PACKET_TYPE_NAMES } from './reticulum.js';
@@ -1057,12 +1058,22 @@ function escapeHtml(str) {
 async function connect(transportType) {
   const btnBle = $('btn-connect-ble');
   const btnSerial = $('btn-connect-serial');
+  const btnWs = $('btn-connect-ws');
   try {
     btnBle.disabled = true;
     btnSerial.disabled = true;
-
-    // Re-instantiate RNode with chosen transport
-    rnode = new RNode(transportType);
+    btnWs.disabled = true;
+
+    // Pick the right interface based on transport type.
+    //   'ble' / 'serial' → RNode-over-KISS (owns a radio)
+    //   'ws'             → rnsd-over-HDLC (no radio, direct to a Reticulum daemon)
+    if (transportType === 'ws') {
+      const url = ($('ws-url').value || '').trim();
+      if (!url) { log('err', 'WebSocket URL is empty'); return; }
+      rnode = new RnsdInterface(url);
+    } else {
+      rnode = new RNode(transportType);
+    }
     rnode._onLog = (msg) => log('info', msg);
     rnode._onPacket = onPacket;
 
@@ -1073,30 +1084,67 @@ async function connect(transportType) {
     $('btn-disconnect').classList.remove('hidden');
     btnBle.classList.add('hidden');
     btnSerial.classList.add('hidden');
-
-    const detected = await rnode.detect();
-    if (!detected) { log('err', 'RNode detect failed'); return; }
-
-    const fw = await rnode.getFirmwareVersion();
-    const battery = await rnode.getBattery();
-    log('ok', `RNode FW ${fw?.major}.${fw?.minor}, Bat ${battery}%`);
-
-    // Show panels
-    $('config-panel').classList.remove('hidden');
-    $('messaging-panel').classList.remove('hidden');
-
-    // Auto-start radio with form values
-    await startRadio();
+    btnWs.classList.add('hidden');
+    $('ws-url-row').classList.add('hidden');
+
+    // Interfaces with an RNode on the other side (BLE/Serial) need
+    // the full detect/fw/battery/radio-config sequence. Interfaces
+    // that talk directly to a Reticulum daemon via WebSocket skip
+    // all of that — there is no radio to configure.
+    const usesRnode = rnode.capabilities?.rnodeControl !== false;
+
+    if (usesRnode) {
+      const detected = await rnode.detect();
+      if (!detected) { log('err', 'RNode detect failed'); return; }
+      const fw = await rnode.getFirmwareVersion();
+      const battery = await rnode.getBattery();
+      log('ok', `RNode FW ${fw?.major}.${fw?.minor}, Bat ${battery}%`);
+      $('config-panel').classList.remove('hidden');
+      $('messaging-panel').classList.remove('hidden');
+      await startRadio();
+    } else {
+      // WebSocket path: no radio config, no detect, no battery.
+      // Go straight to the "ready for messaging" state that
+      // startRadio would have reached for the RNode path.
+      $('messaging-panel').classList.remove('hidden');
+      log('ok', `Connected to Reticulum network via WebSocket`);
+      markInterfaceReady();
+    }
   } catch (e) {
     log('err', 'Connect: ' + e.message);
   } finally {
     btnBle.disabled = false;
     btnSerial.disabled = false;
+    btnWs.disabled = false;
   }
 }
 
+// Flip the "we are ready to send and receive" bit, fire the startup
+// auto-announce, start the periodic announce timer, and start the
+// outbound retry tick. Called from both the RNode path (after
+// startRadio reports the radio is on) and the WebSocket path (after
+// the socket is up — there is no radio to wait for).
+function markInterfaceReady() {
+  radioOn = true;
+  $('radio-status').textContent = 'Ready';
+  $('radio-status').className = 'status-on';
+  sendAnnounce().catch(e => log('info', `Startup announce skipped: ${e.message}`));
+  if (announceTimer) clearInterval(announceTimer);
+  announceTimer = setInterval(() => {
+    if (radioOn) {
+      sendAnnounce().catch(e => log('info', `Periodic announce skipped: ${e.message}`));
+    }
+  }, 5 * 60 * 1000);
+  if (outboundRetryTimer) clearInterval(outboundRetryTimer);
+  outboundRetryTimer = setInterval(() => {
+    outboundRetryTick().catch(e => log('info', `Retry tick error: ${e.message}`));
+  }, MSG_RETRY_TICK_MS);
+  outboundRetryTick().catch(e => log('info', `Retry tick error: ${e.message}`));
+}
+
 $('btn-connect-ble').addEventListener('click', () => connect('ble'));
 $('btn-connect-serial').addEventListener('click', () => connect('serial'));
+$('btn-connect-ws').addEventListener('click', () => connect('ws'));
 
 $('btn-disconnect').addEventListener('click', async () => {
   if (announceTimer) { clearInterval(announceTimer); announceTimer = null; }
@@ -1107,6 +1155,8 @@ $('btn-disconnect').addEventListener('click', async () => {
   $('btn-disconnect').classList.add('hidden');
   $('btn-connect-ble').classList.remove('hidden');
   $('btn-connect-serial').classList.remove('hidden');
+  $('btn-connect-ws').classList.remove('hidden');
+  $('ws-url-row').classList.remove('hidden');
   $('config-panel').classList.add('hidden');
   $('messaging-panel').classList.add('hidden');
   radioOn = false;
@@ -1123,40 +1173,13 @@ async function startRadio() {
     const cr = parseInt($('cfg-cr').value);
     const txp = parseInt($('cfg-txp').value);
     const on = await rnode.configureAndStart({ freq, bw, sf, cr, txp });
-    radioOn = on;
     $('radio-status').textContent = on ? 'Radio: ON' : '';
     $('radio-status').className = on ? 'status-on' : 'status-off';
     if (on) {
       log('ok', 'Radio on');
-      // Emit one announce right away and then again every 5 minutes so
-      // every RNS relay in reach keeps our identity warm in its path
-      // table / known_destinations cache. The relay-side validation of
-      // inbound LRPROOFs calls Identity.recall(destination_hash), and
-      // if our entry has been GC'd or never made it past a further hop
-      // the proof is silently dropped — the exact symptom of incoming
-      // link handshakes stalling. Periodic re-announce is what every
-      // long-running Python RNS daemon does by default (Sideband uses
-      // 30 minutes; we use 5 because the test bench has a small mesh).
-      // Best-effort: swallow errors so a transient send failure can't
-      // take down the timer.
-      sendAnnounce().catch(e => log('info', `Startup announce skipped: ${e.message}`));
-      if (announceTimer) clearInterval(announceTimer);
-      announceTimer = setInterval(() => {
-        if (radioOn) {
-          sendAnnounce().catch(e => log('info', `Periodic announce skipped: ${e.message}`));
-        }
-      }, 5 * 60 * 1000);
-
-      // Start the outbound retry tick now that the radio is up.
-      // Any outbound rows that were saved while the radio was off
-      // will get picked up on the first tick.
-      if (outboundRetryTimer) clearInterval(outboundRetryTimer);
-      outboundRetryTimer = setInterval(() => {
-        outboundRetryTick().catch(e => log('info', `Retry tick error: ${e.message}`));
-      }, MSG_RETRY_TICK_MS);
-      // Kick one immediately so queued rows don't have to wait up
-      // to MSG_RETRY_TICK_MS for their first attempt.
-      outboundRetryTick().catch(e => log('info', `Retry tick error: ${e.message}`));
+      markInterfaceReady();
+    } else {
+      radioOn = false;
     }
   } catch (e) { log('err', 'Radio: ' + e.message); }
 }
@@ -1201,7 +1224,9 @@ $('msg-content').addEventListener('keydown', (e) => {
 // Log
 $('btn-clear-log').addEventListener('click', () => { $('log').innerHTML = ''; });
 
-// Browser check — disable buttons for unsupported transports
+// Browser check — disable buttons for unsupported transports.
+// WebSocket is available in every modern browser, so it never gets
+// disabled; BLE and Serial still depend on Web Bluetooth / Web Serial.
 if (!navigator.bluetooth) {
   $('btn-connect-ble').disabled = true;
   $('btn-connect-ble').textContent = 'Connect (BLE — not supported)';
@@ -1210,7 +1235,11 @@ if (!navigator.serial) {
   $('btn-connect-serial').disabled = true;
   $('btn-connect-serial').textContent = 'Connect (Serial — not supported)';
 }
-if (!navigator.bluetooth && !navigator.serial) {
+if (typeof WebSocket === 'undefined') {
+  $('btn-connect-ws').disabled = true;
+  $('btn-connect-ws').textContent = 'Connect (WebSocket — not supported)';
+}
+if (!navigator.bluetooth && !navigator.serial && typeof WebSocket === 'undefined') {
   $('unsupported').classList.remove('hidden');
 }
 
 
@@ -0,0 +1,86 @@
+// js/hdlc.js — HDLC frame encode/decode for Reticulum's TCP interface.
+//
+// rnsd's TCPClientInterface / TCPServerInterface frames every raw
+// Reticulum packet with HDLC before writing it to the socket, and
+// unframes it on the receive side. Wire format is:
+//
+//   FLAG (0x7E) || escaped(packet_bytes) || FLAG (0x7E)
+//
+// where escaping replaces any in-band 0x7D with 0x7D 0x5D and any
+// in-band 0x7E with 0x7D 0x5E. The reverse applies on unescape.
+//
+// This is a separate module from kiss.js because:
+//   * framing bytes are different (0x7E / 0x7D vs 0xC0 / 0xDB)
+//   * HDLC has no command byte prefix — the frame IS the packet
+//   * there is no RSSI/SNR metadata framing like KISS has
+//
+// Source: RNS/Interfaces/TCPInterface.py class HDLC.
+
+'use strict';
+
+export const FLAG     = 0x7E;
+export const ESC      = 0x7D;
+export const ESC_MASK = 0x20;
+
+// Wrap one complete Reticulum packet into an HDLC frame. Returns
+// FLAG || escaped(data) || FLAG.
+export function encodeFrame(data) {
+  const out = [FLAG];
+  for (const b of data) {
+    if (b === ESC || b === FLAG) {
+      out.push(ESC, b ^ ESC_MASK);
+    } else {
+      out.push(b);
+    }
+  }
+  out.push(FLAG);
+  return new Uint8Array(out);
+}
+
+// Streaming HDLC parser. Feed it bytes as they arrive on the
+// transport (WebSocket messages, TCP chunks, whatever) and it calls
+// onFrame(bytes) for each complete frame boundary it sees. Buffers
+// partial frames across feeds so input chunk sizes do not matter.
+export class HdlcParser {
+  constructor(onFrame) {
+    this.onFrame = onFrame;
+    this._buf = [];
+    this._inFrame = false;
+    this._escape = false;
+  }
+
+  feed(bytes) {
+    for (const b of bytes) {
+      if (b === FLAG) {
+        // A FLAG terminates the current frame (if any) and starts
+        // the next. Empty frames (two FLAGs back to back) are
+        // silently dropped — rnsd uses FLAG as both delimiter and
+        // keepalive.
+        if (this._inFrame && this._buf.length > 0) {
+          this.onFrame(new Uint8Array(this._buf));
+        }
+        this._buf = [];
+        this._inFrame = true;
+        this._escape = false;
+        continue;
+      }
+
+      if (!this._inFrame) continue;
+
+      if (this._escape) {
+        this._escape = false;
+        this._buf.push(b ^ ESC_MASK);
+      } else if (b === ESC) {
+        this._escape = true;
+      } else {
+        this._buf.push(b);
+      }
+    }
+  }
+
+  reset() {
+    this._buf = [];
+    this._inFrame = false;
+    this._escape = false;
+  }
+}
@@ -0,0 +1,101 @@
+// js/rnsd-interface.js — Reticulum-direct interface over a byte stream.
+//
+// Wraps a WebSocketTransport + HdlcParser into the same
+// {connect, disconnect, sendPacket, _onPacket, _onLog} shape
+// js/rnode.js exposes, so app.js can drive either without
+// branching. Unlike rnode.js this module does not speak KISS and
+// does not issue any RNode command — there is no radio on the
+// other end, just an rnsd that will inject our packets into a
+// Reticulum network.
+//
+// Packet flow:
+//   TX: app.js builds a raw Reticulum packet, calls sendPacket(),
+//       we HDLC-frame it and write it to the transport (which hands
+//       it to the WebSocket-to-TCP bridge, which forwards to rnsd).
+//   RX: the bridge delivers bytes from rnsd via the transport, the
+//       HdlcParser emits one complete frame per boundary, each
+//       frame IS a raw Reticulum packet which we hand to _onPacket.
+//
+// Since there is no physical radio, RSSI and SNR are not available.
+// We pass zeros into _onPacket so existing log lines still render.
+
+'use strict';
+
+import { WebSocketTransport } from './websocket-transport.js';
+import { HdlcParser, encodeFrame } from './hdlc.js';
+
+export class RnsdInterface {
+  constructor(url) {
+    this.transport = new WebSocketTransport(url);
+    this._onPacket = null;
+    this._onLog = null;
+
+    // Stream HDLC frames out of whatever byte chunks the transport
+    // delivers. Each complete frame is a raw Reticulum packet; we
+    // forward it to _onPacket with rssi=0 and snr=0.
+    this._parser = new HdlcParser((packet) => {
+      if (this._onPacket) this._onPacket(packet, 0, 0);
+    });
+    this.transport._onReceive = (bytes) => this._parser.feed(bytes);
+  }
+
+  get connected() {
+    return this.transport.connected;
+  }
+
+  // Capability flag consumed by app.js to decide whether to show the
+  // radio config panel and whether to issue RNode-specific commands
+  // (detect, getFirmwareVersion, getBattery, configureAndStart).
+  // None of those apply over a WebSocket-to-rnsd path.
+  get capabilities() {
+    return {
+      rnodeControl: false,
+      radioConfig:  false,
+    };
+  }
+
+  _log(msg) {
+    if (this._onLog) this._onLog(msg);
+  }
+
+  async connect() {
+    this.transport._onLog = (msg) => this._log(msg);
+    this.transport._onDisconnect = () => {
+      this._parser.reset();
+    };
+    await this.transport.connect();
+  }
+
+  async disconnect() {
+    await this.transport.disconnect();
+  }
+
+  // Stubs for the RNode command API so any forgotten caller in
+  // app.js still works without branching. All return benign values;
+  // a future refactor can replace app.js's `await rnode.detect()`
+  // style calls with capability-gated conditionals and delete these.
+  async detect()               { return true; }
+  async getFirmwareVersion()   { return { major: 0, minor: 0 }; }
+  async getPlatform()          { return 0; }
+  async getBoard()             { return 0; }
+  async getBattery()           { return 0; }
+  async setFrequency()         { return 0; }
+  async setBandwidth()         { return 0; }
+  async setSpreadingFactor()   { return 0; }
+  async setCodingRate()        { return 0; }
+  async setTxPower()           { return 0; }
+  async setRadioState()        { return true; }
+  async configureAndStart()    { return true; }
+  async blink()                { }
+
+  // Send a raw Reticulum packet. HDLC-frame it and push it through
+  // the transport in one write. rnsd's TCPClientInterface on the
+  // other side will strip the framing and hand the packet to its
+  // Transport for onward routing.
+  async sendPacket(data) {
+    if (!this.transport.connected) throw new Error('WebSocket not connected');
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+    const frame = encodeFrame(bytes);
+    await this.transport.write(frame);
+  }
+}