neoagent 2.3.1-beta.32 → 2.3.1-beta.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.32",
+  "version": "2.3.1-beta.33",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",
@@ -54,7 +54,6 @@
     "@anthropic-ai/sdk": "^0.39.0",
     "@google/generative-ai": "^0.24.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@meshtastic/core": "^2.6.7",
     "baileys": "^6.7.21",
     "bcrypt": "^6.0.0",
     "better-sqlite3": "^11.8.1",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "987887827" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "2675743838" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/messaging/meshtastic.js

@@ -3,12 +3,11 @@
 const { BasePlatform } = require('./base');
 const { readMeshtasticEnabled } = require('./meshtastic_env');
 const { MeshtasticTcpTransport } = require('./meshtastic_tcp_transport');
+const { BROADCAST_NUM } = require('./meshtastic_protocol');
 
 const DEFAULT_TCP_PORT = 4403;
 const DEFAULT_CHANNEL = 0;
 
-let meshtasticModulesPromise = null;
-
 function requireText(value, label) {
   const text = String(value || '').trim();
   if (!text) throw new Error(`${label} is required`);
@@ -47,31 +46,6 @@ function parseChannel(value) {
   return channel;
 }
 
-async function loadMeshtasticModules() {
-  if (!meshtasticModulesPromise) {
-    meshtasticModulesPromise = import('@meshtastic/core').then((core) => ({
-      MeshDevice: core.MeshDevice,
-      Types: core.Types,
-      createTransport: (hostname, port, timeout) =>
-        MeshtasticTcpTransport.create(core, hostname, port, timeout),
-    })).catch((error) => {
-      meshtasticModulesPromise = null;
-      const message = String(error?.message || error || '');
-      if (
-        error?.code === 'ERR_MODULE_NOT_FOUND'
-        || /Cannot find package '@meshtastic\/core'/.test(message)
-        || /Cannot find module '@meshtastic\/core'/.test(message)
-      ) {
-        throw new Error(
-          'Meshtastic support is not installed. Install @meshtastic/core or disable the Meshtastic integration.'
-        );
-      }
-      throw error;
-    });
-  }
-  return meshtasticModulesPromise;
-}
-
 function normalizeNodeId(value) {
   const text = String(value || '').trim();
   if (!text) return '';
@@ -99,13 +73,8 @@ class MeshtasticPlatform extends BasePlatform {
     this.channel = DEFAULT_CHANNEL;
     this.authInfo = null;
     this._transport = null;
-    this._device = null;
-    this._modules = null;
     this._connectPromise = null;
     this._disconnecting = false;
-    this._configured = false;
-    this._lastMyNodeInfo = null;
-    this._lastNodeUsers = new Map();
   }
 
   async connect() {
@@ -131,99 +100,31 @@ class MeshtasticPlatform extends BasePlatform {
     this.port = endpoint.port;
     this.channel = parseChannel(this.config.channel);
     this._disconnecting = false;
-    this._configured = false;
-    this._lastMyNodeInfo = null;
-    this._lastNodeUsers.clear();
     this.status = 'connecting';
 
-    const modules = await loadMeshtasticModules();
-    this._modules = modules;
-
-    const transport = await modules.createTransport(this.host, this.port, 60000);
+    const transport = await MeshtasticTcpTransport.create(this.host, this.port, 60000);
     this._transport = transport;
 
-    const device = new modules.MeshDevice(transport);
-    this._device = device;
-    this._wireDeviceEvents(device, modules.Types);
-
-    const ready = new Promise((resolve, reject) => {
-      let settled = false;
-      const resolveOnce = () => {
-        if (settled) return;
-        settled = true;
-        resolve({ status: this.status });
-      };
-      const rejectOnce = (error) => {
-        if (settled) return;
-        settled = true;
-        reject(error);
-      };
-
-      device.events.onDeviceStatus.subscribe((status) => {
-        if (status === modules.Types.DeviceStatusEnum.DeviceConnected) {
-          device.configure().catch((error) => {
-            if (!this._disconnecting) {
-              rejectOnce(error);
-            }
-          });
-          return;
-        }
-
-        if (status === modules.Types.DeviceStatusEnum.DeviceConfigured) {
-          this._configured = true;
-          this.status = 'connected';
-          this.authInfo = this._buildAuthInfo();
-          this.emit('connected');
-          resolveOnce();
-          return;
-        }
-
-        if (status === modules.Types.DeviceStatusEnum.DeviceDisconnected) {
-          this.status = 'disconnected';
-          if (!this._disconnecting) {
-            const error = new Error('Meshtastic device disconnected');
-            rejectOnce(error);
-            this.emit('disconnected', { reason: 'device_disconnected' });
-          }
-        }
-      });
-    });
+    const conn = transport.connection;
 
-    await ready;
-    return { status: this.status };
-  }
-
-  _wireDeviceEvents(device, Types) {
-    device.events.onMyNodeInfo.subscribe((info) => {
-      this._lastMyNodeInfo = info;
-      this.authInfo = this._buildAuthInfo();
+    conn.on('myNodeInfo', () => {
+      this.authInfo = this._buildAuthInfo(conn);
     });
 
-    device.events.onUserPacket.subscribe((packet) => {
-      const user = packet?.data;
-      const from = Number(packet?.from || 0);
-      if (!user || !Number.isFinite(from) || from <= 0) return;
-      this._lastNodeUsers.set(from, user);
-    });
+    conn.on('textMessage', (msg) => {
+      if (msg.channel !== this.channel) return;
+
+      const localNodeNum = conn.myNodeNum;
+      if (msg.from > 0 && localNodeNum > 0 && msg.from === localNodeNum) return;
 
-    device.events.onMessagePacket.subscribe((packet) => {
-      if (!packet) return;
-      const channel = Number(packet.channel);
-      if (channel !== this.channel) return;
-
-      const senderNum = Number(packet.from || 0);
-      const localNodeNum = Number(this._lastMyNodeInfo?.myNodeNum || 0);
-      if (senderNum > 0 && localNodeNum > 0 && senderNum === localNodeNum) {
-        return;
-      }
-      const senderUser = this._lastNodeUsers.get(senderNum) || null;
+      const senderUser = conn.nodeUsers.get(msg.from) || null;
       const senderName = senderUser?.longName || senderUser?.shortName || null;
       const senderUsername = normalizeNodeId(senderUser?.id || '');
-      const chatId = `channel:${channel}`;
+      const chatId = `channel:${msg.channel}`;
 
       const access = this._checkInboundAccess({
         platform: this.name,
-        senderId: String(senderNum || ''),
+        senderId: String(msg.from || ''),
         chatId,
         isDirect: false,
         isShared: true,
@@ -245,35 +146,46 @@ class MeshtasticPlatform extends BasePlatform {
 
       this.emit('message', {
         chatId,
-        sender: String(senderNum || ''),
+        sender: String(msg.from || ''),
         senderName,
         senderUsername: senderUsername || null,
         senderTag: senderUsername || null,
-        content: String(packet.data || ''),
+        content: msg.data,
         mediaType: null,
         isGroup: true,
-        messageId: String(packet.id || `${Date.now()}`),
-        timestamp: toIsoTimestamp(packet.rxTime),
+        messageId: String(msg.id || `${Date.now()}`),
+        timestamp: toIsoTimestamp(msg.rxTime),
         metadata: {
-          channel,
+          channel: msg.channel,
           host: this.host,
           meshNodeId: senderUsername || null,
-          meshDestination: packet.type || 'broadcast',
+          meshDestination: msg.type || 'broadcast',
         },
         rawMessage: {
-          id: packet.id,
-          from: packet.from,
-          to: packet.to,
-          type: packet.type,
-          channel: packet.channel,
+          id: msg.id,
+          from: msg.from,
+          to: msg.to,
+          type: msg.type,
+          channel: msg.channel,
         },
       });
     });
+
+    conn.on('disconnected', (info) => {
+      if (this._disconnecting) return;
+      this.status = 'disconnected';
+      this.emit('disconnected', { reason: info?.reason || 'device_disconnected' });
+    });
+
+    this.status = 'connected';
+    this.authInfo = this._buildAuthInfo(conn);
+    this.emit('connected');
+    return { status: this.status };
   }
 
-  _buildAuthInfo() {
-    const info = this._lastMyNodeInfo || {};
-    const user = info.user || {};
+  _buildAuthInfo(conn) {
+    const nodeNum = conn?.myNodeNum || 0;
+    const user = conn?.nodeUsers.get(nodeNum) || {};
     return {
       label: user.longName || user.shortName || normalizeNodeId(user.id) || this.host || 'Meshtastic',
       nodeId: normalizeNodeId(user.id),
@@ -283,7 +195,7 @@ class MeshtasticPlatform extends BasePlatform {
   }
 
   async sendMessage(to, content) {
-    if (this.status !== 'connected' || !this._device || !this._modules) {
+    if (this.status !== 'connected' || !this._transport) {
       throw new Error('Meshtastic is not connected');
     }
 
@@ -292,11 +204,11 @@ class MeshtasticPlatform extends BasePlatform {
       throw new Error(`Meshtastic is configured for channel ${this.channel}`);
     }
 
-    await this._device.sendText(
+    await this._transport.connection.sendText(
       String(content || ''),
-      'broadcast',
-      true,
       this.channel,
+      BROADCAST_NUM,
+      true,
     );
     return { success: true };
   }
@@ -305,15 +217,10 @@ class MeshtasticPlatform extends BasePlatform {
     this._disconnecting = true;
     this.status = 'disconnected';
 
-    const device = this._device;
     const transport = this._transport;
-    this._device = null;
     this._transport = null;
-    this._configured = false;
 
-    if (device && typeof device.disconnect === 'function') {
-      await device.disconnect().catch(() => {});
-    } else if (transport && typeof transport.disconnect === 'function') {
+    if (transport) {
       await transport.disconnect().catch(() => {});
     }
   }
@@ -323,7 +230,7 @@ class MeshtasticPlatform extends BasePlatform {
   }
 
   getAuthInfo() {
-    return this.authInfo || this._buildAuthInfo();
+    return this.authInfo || this._buildAuthInfo(this._transport?.connection);
   }
 }
 

package/server/services/messaging/meshtastic_protocol.js

@@ -0,0 +1,473 @@
+'use strict';
+
+const { Socket } = require('node:net');
+const { EventEmitter } = require('node:events');
+
+// Meshtastic TCP wire framing constants (from public protocol docs)
+const FRAME_START_1 = 0x94;
+const FRAME_START_2 = 0xC3;
+
+const BROADCAST_NUM = 0xFFFFFFFF;
+
+// PortNum values from public protocol specification
+const PortNum = Object.freeze({
+  UNKNOWN_APP: 0,
+  TEXT_MESSAGE_APP: 1,
+  POSITION_APP: 3,
+  NODEINFO_APP: 4,
+  ROUTING_APP: 5,
+  ADMIN_APP: 6,
+  TELEMETRY_APP: 67,
+});
+
+// --------------------------------------------------------------------------
+// Minimal protobuf wire-format encoder/decoder (Google public standard)
+// Implements only the subset needed: varint, length-delimited, fixed32
+// --------------------------------------------------------------------------
+
+const WIRE_VARINT = 0;
+const WIRE_FIXED64 = 1;
+const WIRE_LENGTH_DELIMITED = 2;
+const WIRE_FIXED32 = 5;
+
+function encodeVarint(value) {
+  const bytes = [];
+  let v = value >>> 0;
+  while (v > 0x7F) {
+    bytes.push((v & 0x7F) | 0x80);
+    v >>>= 7;
+  }
+  bytes.push(v & 0x7F);
+  return bytes;
+}
+
+function encodeTag(fieldNumber, wireType) {
+  return encodeVarint((fieldNumber << 3) | wireType);
+}
+
+function encodeVarintField(fieldNumber, value) {
+  if (value === 0 || value == null) return [];
+  return [...encodeTag(fieldNumber, WIRE_VARINT), ...encodeVarint(value)];
+}
+
+function encodeBoolField(fieldNumber, value) {
+  if (!value) return [];
+  return [...encodeTag(fieldNumber, WIRE_VARINT), 1];
+}
+
+function encodeFixed32Field(fieldNumber, value) {
+  if (value === 0 || value == null) return [];
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32LE(value >>> 0);
+  return [...encodeTag(fieldNumber, WIRE_FIXED32), ...buf];
+}
+
+function encodeBytesField(fieldNumber, bytes) {
+  if (!bytes || bytes.length === 0) return [];
+  return [
+    ...encodeTag(fieldNumber, WIRE_LENGTH_DELIMITED),
+    ...encodeVarint(bytes.length),
+    ...bytes,
+  ];
+}
+
+function encodeStringField(fieldNumber, str) {
+  if (!str) return [];
+  return encodeBytesField(fieldNumber, Buffer.from(str, 'utf8'));
+}
+
+function encodeMessageField(fieldNumber, messageBytes) {
+  return encodeBytesField(fieldNumber, messageBytes);
+}
+
+function decodeVarint(buf, offset) {
+  let result = 0;
+  let shift = 0;
+  let pos = offset;
+  while (pos < buf.length) {
+    const b = buf[pos++];
+    result |= (b & 0x7F) << shift;
+    if ((b & 0x80) === 0) return { value: result >>> 0, offset: pos };
+    shift += 7;
+    if (shift > 35) throw new Error('Varint too long');
+  }
+  throw new Error('Unexpected end of varint');
+}
+
+function decodeFields(buf) {
+  const fields = [];
+  let offset = 0;
+  while (offset < buf.length) {
+    const tag = decodeVarint(buf, offset);
+    offset = tag.offset;
+    const fieldNumber = tag.value >>> 3;
+    const wireType = tag.value & 0x07;
+
+    switch (wireType) {
+      case WIRE_VARINT: {
+        const val = decodeVarint(buf, offset);
+        offset = val.offset;
+        fields.push({ field: fieldNumber, wire: wireType, value: val.value });
+        break;
+      }
+      case WIRE_FIXED64: {
+        offset += 8;
+        break;
+      }
+      case WIRE_LENGTH_DELIMITED: {
+        const len = decodeVarint(buf, offset);
+        offset = len.offset;
+        const data = buf.subarray(offset, offset + len.value);
+        offset += len.value;
+        fields.push({ field: fieldNumber, wire: wireType, value: data });
+        break;
+      }
+      case WIRE_FIXED32: {
+        const val32 = buf.readUInt32LE(offset);
+        offset += 4;
+        fields.push({ field: fieldNumber, wire: wireType, value: val32 });
+        break;
+      }
+      default:
+        throw new Error(`Unsupported wire type ${wireType}`);
+    }
+  }
+  return fields;
+}
+
+function getField(fields, fieldNumber) {
+  return fields.find((f) => f.field === fieldNumber) || null;
+}
+
+// --------------------------------------------------------------------------
+// Protocol message builders and parsers
+// Field numbers from the public Meshtastic protobuf specification
+// --------------------------------------------------------------------------
+
+function encodeData(payload, portnum, opts = {}) {
+  return new Uint8Array([
+    ...encodeVarintField(1, portnum),
+    ...encodeBytesField(2, payload),
+    ...encodeBoolField(3, opts.wantResponse),
+    ...encodeFixed32Field(6, opts.requestId),
+    ...encodeFixed32Field(7, opts.replyId),
+    ...encodeFixed32Field(8, opts.emoji),
+  ]);
+}
+
+function encodeMeshPacket(from, to, channel, id, decoded, opts = {}) {
+  return new Uint8Array([
+    ...encodeFixed32Field(1, from),
+    ...encodeFixed32Field(2, to),
+    ...encodeVarintField(3, channel),
+    ...encodeMessageField(4, decoded),
+    ...encodeFixed32Field(6, id),
+    ...encodeBoolField(10, opts.wantAck),
+  ]);
+}
+
+function encodeToRadioPacket(meshPacketBytes) {
+  return new Uint8Array(encodeMessageField(1, meshPacketBytes));
+}
+
+function encodeToRadioWantConfig(configId) {
+  return new Uint8Array(encodeVarintField(3, configId));
+}
+
+function decodeUser(buf) {
+  const fields = decodeFields(buf);
+  return {
+    id: getField(fields, 1)?.value?.toString('utf8') || '',
+    longName: getField(fields, 2)?.value?.toString('utf8') || '',
+    shortName: getField(fields, 3)?.value?.toString('utf8') || '',
+  };
+}
+
+function decodeData(buf) {
+  const fields = decodeFields(buf);
+  return {
+    portnum: getField(fields, 1)?.value || 0,
+    payload: getField(fields, 2)?.value || Buffer.alloc(0),
+    wantResponse: !!(getField(fields, 3)?.value),
+    source: getField(fields, 5)?.value || 0,
+    dest: getField(fields, 4)?.value || 0,
+    requestId: getField(fields, 6)?.value || 0,
+  };
+}
+
+function decodeMeshPacket(buf) {
+  const fields = decodeFields(buf);
+  const decodedField = getField(fields, 4);
+  const encryptedField = getField(fields, 5);
+  return {
+    from: getField(fields, 1)?.value || 0,
+    to: getField(fields, 2)?.value || 0,
+    channel: getField(fields, 3)?.value || 0,
+    decoded: decodedField ? decodeData(decodedField.value) : null,
+    encrypted: encryptedField ? encryptedField.value : null,
+    id: getField(fields, 6)?.value || 0,
+    rxTime: getField(fields, 7)?.value || 0,
+  };
+}
+
+function decodeNodeInfo(buf) {
+  const fields = decodeFields(buf);
+  const userField = getField(fields, 2);
+  return {
+    num: getField(fields, 1)?.value || 0,
+    user: userField ? decodeUser(userField.value) : null,
+  };
+}
+
+function decodeMyNodeInfo(buf) {
+  const fields = decodeFields(buf);
+  return {
+    myNodeNum: getField(fields, 1)?.value || 0,
+  };
+}
+
+function decodeFromRadio(buf) {
+  const fields = decodeFields(buf);
+  const id = getField(fields, 1)?.value || 0;
+
+  const packetField = getField(fields, 2);
+  if (packetField) return { id, type: 'packet', packet: decodeMeshPacket(packetField.value) };
+
+  const myInfoField = getField(fields, 3);
+  if (myInfoField) return { id, type: 'myInfo', myInfo: decodeMyNodeInfo(myInfoField.value) };
+
+  const nodeInfoField = getField(fields, 4);
+  if (nodeInfoField) return { id, type: 'nodeInfo', nodeInfo: decodeNodeInfo(nodeInfoField.value) };
+
+  const configCompleteField = getField(fields, 7);
+  if (configCompleteField) return { id, type: 'configComplete', configId: configCompleteField.value };
+
+  const rebootedField = getField(fields, 8);
+  if (rebootedField) return { id, type: 'rebooted' };
+
+  return { id, type: 'unknown' };
+}
+
+// --------------------------------------------------------------------------
+// TCP wire framing: [0x94, 0xC3, len_msb, len_lsb, ...protobuf_payload]
+// --------------------------------------------------------------------------
+
+function framePacket(protobufBytes) {
+  const len = protobufBytes.length;
+  const frame = Buffer.alloc(4 + len);
+  frame[0] = FRAME_START_1;
+  frame[1] = FRAME_START_2;
+  frame[2] = (len >> 8) & 0xFF;
+  frame[3] = len & 0xFF;
+  frame.set(protobufBytes, 4);
+  return frame;
+}
+
+function createFrameParser(onPacket) {
+  let buffer = Buffer.alloc(0);
+  return (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (buffer.length >= 4) {
+      const idx = buffer.indexOf(FRAME_START_1);
+      if (idx === -1) { buffer = Buffer.alloc(0); return; }
+      if (idx > 0) { buffer = buffer.subarray(idx); }
+      if (buffer.length < 2) return;
+      if (buffer[1] !== FRAME_START_2) { buffer = buffer.subarray(1); continue; }
+      if (buffer.length < 4) return;
+      const payloadLen = (buffer[2] << 8) | buffer[3];
+      if (buffer.length < 4 + payloadLen) return;
+      const payload = buffer.subarray(4, 4 + payloadLen);
+      buffer = buffer.subarray(4 + payloadLen);
+      onPacket(payload);
+    }
+  };
+}
+
+// --------------------------------------------------------------------------
+// MeshtasticConnection — TCP connection + protocol state machine
+// --------------------------------------------------------------------------
+
+class MeshtasticConnection extends EventEmitter {
+  constructor() {
+    super();
+    this._socket = null;
+    this._configId = (Math.random() * 0x7FFFFFFF) >>> 0;
+    this._myNodeNum = 0;
+    this._configured = false;
+    this._closing = false;
+    this._nodeUsers = new Map();
+  }
+
+  get myNodeNum() { return this._myNodeNum; }
+  get nodeUsers() { return this._nodeUsers; }
+  get configured() { return this._configured; }
+
+  async connect(host, port, timeout = 60000) {
+    if (this._socket) throw new Error('Already connected');
+    this._closing = false;
+    this._configured = false;
+    this._myNodeNum = 0;
+    this._nodeUsers.clear();
+
+    return new Promise((resolve, reject) => {
+      const socket = new Socket();
+      let settled = false;
+
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        socket.destroy();
+        reject(err);
+      };
+
+      const timer = setTimeout(() => fail(new Error('Connection timeout')), timeout);
+
+      socket.once('error', fail);
+      socket.once('ready', () => {
+        socket.removeListener('error', fail);
+        this._socket = socket;
+        this._wireSocket(socket);
+        this.emit('status', 'connected');
+
+        const onConfigured = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve();
+        };
+        this.once('configured', onConfigured);
+
+        const toRadio = encodeToRadioWantConfig(this._configId);
+        socket.write(framePacket(toRadio));
+      });
+
+      socket.setTimeout(timeout);
+      socket.connect(port, host);
+    });
+  }
+
+  _wireSocket(socket) {
+    const parser = createFrameParser((payload) => {
+      if (this._closing) return;
+      try {
+        const msg = decodeFromRadio(payload);
+        this._handleFromRadio(msg);
+      } catch (err) {
+        this.emit('error', err);
+      }
+    });
+
+    socket.on('data', parser);
+    socket.on('error', () => this._onDisconnected('socket-error'));
+    socket.on('end', () => this._onDisconnected('socket-end'));
+    socket.on('close', () => this._onDisconnected('socket-closed'));
+    socket.on('timeout', () => {
+      this._onDisconnected('socket-timeout');
+      socket.destroy();
+    });
+  }
+
+  _onDisconnected(reason) {
+    if (this._closing) return;
+    this._configured = false;
+    this.emit('status', 'disconnected');
+    this.emit('disconnected', { reason });
+  }
+
+  _handleFromRadio(msg) {
+    switch (msg.type) {
+      case 'myInfo':
+        this._myNodeNum = msg.myInfo.myNodeNum;
+        this.emit('myNodeInfo', msg.myInfo);
+        break;
+
+      case 'nodeInfo':
+        if (msg.nodeInfo.user && msg.nodeInfo.num) {
+          this._nodeUsers.set(msg.nodeInfo.num, msg.nodeInfo.user);
+          this.emit('nodeInfo', msg.nodeInfo);
+        }
+        break;
+
+      case 'configComplete':
+        if (msg.configId === this._configId) {
+          this._configured = true;
+          this.emit('configured');
+        }
+        break;
+
+      case 'rebooted':
+        this._configured = false;
+        this._socket?.write(framePacket(encodeToRadioWantConfig(this._configId)));
+        break;
+
+      case 'packet': {
+        const pkt = msg.packet;
+        if (!pkt.decoded) break;
+        this._handleDecodedPacket(pkt);
+        break;
+      }
+    }
+  }
+
+  _handleDecodedPacket(pkt) {
+    const { decoded } = pkt;
+
+    switch (decoded.portnum) {
+      case PortNum.TEXT_MESSAGE_APP:
+        this.emit('textMessage', {
+          id: pkt.id,
+          from: pkt.from,
+          to: pkt.to,
+          channel: pkt.channel,
+          rxTime: pkt.rxTime,
+          type: pkt.to === BROADCAST_NUM ? 'broadcast' : 'direct',
+          data: decoded.payload.toString('utf8'),
+        });
+        break;
+
+      case PortNum.NODEINFO_APP:
+        try {
+          const user = decodeUser(decoded.payload);
+          if (pkt.from) this._nodeUsers.set(pkt.from, user);
+          this.emit('nodeInfo', { num: pkt.from, user });
+        } catch {}
+        break;
+    }
+  }
+
+  async sendText(text, channel = 0, destination = BROADCAST_NUM, wantAck = true) {
+    if (!this._socket || !this._configured) throw new Error('Not connected');
+    const payload = Buffer.from(text, 'utf8');
+    const data = encodeData(payload, PortNum.TEXT_MESSAGE_APP, { wantResponse: false });
+    const id = (Math.random() * 0x7FFFFFFF) >>> 0;
+    const packet = encodeMeshPacket(this._myNodeNum, destination, channel, id, data, { wantAck });
+    const toRadio = encodeToRadioPacket(packet);
+    this._socket.write(framePacket(toRadio));
+    return id;
+  }
+
+  async disconnect() {
+    this._closing = true;
+    this._configured = false;
+    const socket = this._socket;
+    this._socket = null;
+    if (socket) {
+      socket.removeAllListeners();
+      socket.destroy();
+    }
+  }
+}
+
+module.exports = {
+  MeshtasticConnection,
+  PortNum,
+  BROADCAST_NUM,
+  encodeVarint,
+  decodeVarint,
+  decodeFields,
+  decodeFromRadio,
+  decodeMeshPacket,
+  decodeUser,
+  framePacket,
+  createFrameParser,
+};

package/server/services/messaging/meshtastic_tcp_transport.js

@@ -1,144 +1,22 @@
 'use strict';
 
-const { Socket } = require('node:net');
-const { Readable, Writable } = require('node:stream');
+const { MeshtasticConnection } = require('./meshtastic_protocol');
 
 class MeshtasticTcpTransport {
-  static async create(core, hostname, port = 4403, timeout = 60000) {
-    return await new Promise((resolve, reject) => {
-      const socket = new Socket();
-      const onError = (error) => {
-        socket.destroy();
-        socket.removeAllListeners();
-        reject(error);
-      };
-
-      socket.once('error', onError);
-      socket.once('ready', () => {
-        socket.removeListener('error', onError);
-        resolve(new MeshtasticTcpTransport(core, socket));
-      });
-
-      socket.setTimeout(timeout);
-      socket.connect(port, hostname);
-    });
+  constructor(connection) {
+    this._connection = connection;
   }
 
-  constructor(core, connection) {
-    this._core = core;
-    this._socket = connection;
-    this._lastStatus = core.Types.DeviceStatusEnum.DeviceDisconnected;
-    this._closingByUser = false;
-    this._errored = false;
-    this._fromDeviceController = null;
-    this._pipePromise = null;
-    this._abortController = new AbortController();
-
-    this._socket.on('error', () => {
-      this._errored = true;
-      this._socket?.removeAllListeners();
-      this._socket?.destroy();
-      if (!this._closingByUser) {
-        this._emitStatus(core.Types.DeviceStatusEnum.DeviceDisconnected, 'socket-error');
-      }
-    });
-
-    this._socket.on('end', () => {
-      if (this._closingByUser) return;
-      this._emitStatus(core.Types.DeviceStatusEnum.DeviceDisconnected, 'socket-end');
-      this._socket?.removeAllListeners();
-      this._socket?.destroy();
-    });
-
-    this._socket.on('timeout', () => {
-      this._emitStatus(core.Types.DeviceStatusEnum.DeviceDisconnected, 'socket-timeout');
-      this._socket?.removeAllListeners();
-      this._socket?.destroy();
-    });
-
-    this._socket.on('close', () => {
-      if (this._closingByUser) return;
-      this._emitStatus(core.Types.DeviceStatusEnum.DeviceDisconnected, 'socket-closed');
-    });
-
-    const transformed = Readable.toWeb(connection).pipeThrough(core.Utils.fromDeviceStream());
-    this._fromDevice = new ReadableStream({
-      start: async (controller) => {
-        this._fromDeviceController = controller;
-        this._emitStatus(core.Types.DeviceStatusEnum.DeviceConnecting);
-        this._emitStatus(core.Types.DeviceStatusEnum.DeviceConnected);
-        const reader = transformed.getReader();
-
-        try {
-          while (true) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            controller.enqueue(value);
-          }
-          controller.close();
-        } catch (error) {
-          if (this._closingByUser || this._errored) {
-            controller.close();
-          } else {
-            this._emitStatus(core.Types.DeviceStatusEnum.DeviceDisconnected, 'read-error');
-            controller.error(error instanceof Error ? error : new Error(String(error)));
-          }
-
-          try {
-            await transformed.cancel();
-          } catch {}
-        } finally {
-          reader.releaseLock();
-        }
-      },
-    });
-
-    const toDeviceTransform = core.Utils.toDeviceStream();
-    this._toDevice = toDeviceTransform.writable;
-    this._pipePromise = toDeviceTransform.readable.pipeTo(
-      Writable.toWeb(connection),
-      { signal: this._abortController.signal }
-    ).catch((error) => {
-      if (this._abortController.signal.aborted || this._socket?.destroyed) return;
-      const socketError = error instanceof Error ? error : new Error(String(error));
-      this._socket?.destroy(socketError);
-    });
+  static async create(hostname, port = 4403, timeout = 60000) {
+    const connection = new MeshtasticConnection();
+    await connection.connect(hostname, port, timeout);
+    return new MeshtasticTcpTransport(connection);
   }
 
-  get toDevice() {
-    return this._toDevice;
-  }
-
-  get fromDevice() {
-    return this._fromDevice;
-  }
+  get connection() { return this._connection; }
 
   async disconnect() {
-    try {
-      this._closingByUser = true;
-      this._emitStatus(this._core.Types.DeviceStatusEnum.DeviceDisconnected, 'user');
-      this._abortController.abort();
-      if (this._pipePromise) {
-        await this._pipePromise;
-      }
-      this._socket?.destroy();
-    } finally {
-      this._socket = null;
-      this._closingByUser = false;
-      this._errored = false;
-    }
-  }
-
-  _emitStatus(nextStatus, reason) {
-    if (nextStatus === this._lastStatus) return;
-    this._lastStatus = nextStatus;
-    this._fromDeviceController?.enqueue({
-      type: 'status',
-      data: {
-        status: nextStatus,
-        reason,
-      },
-    });
+    await this._connection.disconnect();
   }
 }