neoagent 2.3.1-beta.30 → 2.3.1-beta.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.30",
+  "version": "2.3.1-beta.32",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",
@@ -55,7 +55,6 @@
     "@google/generative-ai": "^0.24.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@meshtastic/core": "^2.6.7",
-    "@meshtastic/transport-node": "^0.0.2",
     "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: "3171035555" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "987887827" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/messaging/meshtastic.js

@@ -2,6 +2,7 @@
 
 const { BasePlatform } = require('./base');
 const { readMeshtasticEnabled } = require('./meshtastic_env');
+const { MeshtasticTcpTransport } = require('./meshtastic_tcp_transport');
 
 const DEFAULT_TCP_PORT = 4403;
 const DEFAULT_CHANNEL = 0;
@@ -48,14 +49,25 @@ function parseChannel(value) {
 
 async function loadMeshtasticModules() {
   if (!meshtasticModulesPromise) {
-    meshtasticModulesPromise = Promise.all([
-      import('@meshtastic/core'),
-      import('@meshtastic/transport-node'),
-    ]).then(([core, transport]) => ({
+    meshtasticModulesPromise = import('@meshtastic/core').then((core) => ({
       MeshDevice: core.MeshDevice,
       Types: core.Types,
-      TransportNode: transport.TransportNode,
-    }));
+      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;
 }
@@ -127,7 +139,7 @@ class MeshtasticPlatform extends BasePlatform {
     const modules = await loadMeshtasticModules();
     this._modules = modules;
 
-    const transport = await modules.TransportNode.create(this.host, this.port, 60000);
+    const transport = await modules.createTransport(this.host, this.port, 60000);
     this._transport = transport;
 
     const device = new modules.MeshDevice(transport);

package/server/services/messaging/meshtastic_tcp_transport.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const { Socket } = require('node:net');
+const { Readable, Writable } = require('node:stream');
+
+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(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);
+    });
+  }
+
+  get toDevice() {
+    return this._toDevice;
+  }
+
+  get fromDevice() {
+    return this._fromDevice;
+  }
+
+  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,
+      },
+    });
+  }
+}
+
+module.exports = {
+  MeshtasticTcpTransport,
+};