neoagent 2.3.1-beta.44 → 2.3.1-beta.46

package/server/routes/settings.js

@@ -23,8 +23,6 @@ const {
 } = require('../services/ai/settings');
 const {
   readMeshtasticEnabled,
-  setMeshtasticEnabled,
-  resetMeshtasticEnabled,
 } = require('../services/messaging/meshtastic_env');
 const {
   ensureDefaultRuntimeSettings,
@@ -84,6 +82,10 @@ const ENV_BACKED_SETTING_KEYS = new Set([
   'meshtastic_enabled',
 ]);
 
+const READ_ONLY_ENV_SETTING_KEYS = new Set([
+  'meshtastic_enabled',
+]);
+
 function toOptionalTrimmedString(value) {
   if (typeof value !== 'string') return undefined;
   const trimmed = value.trim();
@@ -175,14 +177,8 @@ function readEnvBackedSettingValue(key) {
 
 async function writeEnvBackedSettingValue(req, key, value) {
   switch (key) {
-    case 'meshtastic_enabled': {
-      const enabled = setMeshtasticEnabled(value);
-      const manager = req.app?.locals?.messagingManager;
-      if (manager && typeof manager.updateMeshtasticEnabled === 'function') {
-        await manager.updateMeshtasticEnabled(enabled);
-      }
-      return enabled;
-    }
+    case 'meshtastic_enabled':
+      return readMeshtasticEnabled();
     default:
       return value;
   }
@@ -191,11 +187,6 @@ async function writeEnvBackedSettingValue(req, key, value) {
 async function resetEnvBackedSettingValue(req, key) {
   switch (key) {
     case 'meshtastic_enabled': {
-      resetMeshtasticEnabled();
-      const manager = req.app?.locals?.messagingManager;
-      if (manager && typeof manager.updateMeshtasticEnabled === 'function') {
-        await manager.updateMeshtasticEnabled(readMeshtasticEnabled());
-      }
       return;
     }
     default:
@@ -292,6 +283,10 @@ router.put('/', async (req, res) => {
   }
 
   for (const key of Object.keys(normalizedBody)) {
+    if (READ_ONLY_ENV_SETTING_KEYS.has(key)) {
+      delete normalizedBody[key];
+      continue;
+    }
     if (isEnvBackedSettingKey(key)) {
       normalizedBody[key] = await writeEnvBackedSettingValue(req, key, normalizedBody[key]);
     }
@@ -470,6 +465,13 @@ router.put('/:key', async (req, res) => {
   const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
   ensureDefaultRuntimeSettings(userId);
   let value = req.body.value;
+  if (READ_ONLY_ENV_SETTING_KEYS.has(req.params.key)) {
+    return res.status(403).json({
+      success: false,
+      error: `${req.params.key} is managed via environment only`,
+      value: readEnvBackedSettingValue(req.params.key),
+    });
+  }
   if (isEnvBackedSettingKey(req.params.key)) {
     const saved = await writeEnvBackedSettingValue(req, req.params.key, value);
     return res.json({ success: true, value: saved });
@@ -535,6 +537,13 @@ router.put('/:key', async (req, res) => {
 
 // Delete setting
 router.delete('/:key', (req, res) => {
+  if (READ_ONLY_ENV_SETTING_KEYS.has(req.params.key)) {
+    return res.status(403).json({
+      success: false,
+      error: `${req.params.key} is managed via environment only`,
+      value: readEnvBackedSettingValue(req.params.key),
+    });
+  }
   if (isEnvBackedSettingKey(req.params.key)) {
     return resetEnvBackedSettingValue(req, req.params.key)
       .then(() => res.json({ success: true }))

package/server/services/ai/engine.js

@@ -1551,6 +1551,7 @@ class AgentEngine {
       agentId,
       triggerType,
       triggerSource,
+      widgetId: options.widgetId || null,
     });
     const mcpManager = app?.locals?.mcpManager || app?.locals?.mcpClient || this.mcpManager;
     const integrationManager = app?.locals?.integrationManager || null;

package/server/services/messaging/meshtastic.js

@@ -103,6 +103,12 @@ class MeshtasticPlatform extends BasePlatform {
     this._disconnecting = false;
     this.status = 'connecting';
 
+    const staleTransport = this._transport;
+    this._transport = null;
+    if (staleTransport) {
+      await staleTransport.disconnect().catch(() => {});
+    }
+
     const transport = await MeshtasticTcpTransport.create(this.host, this.port, 60000);
     this._transport = transport;
 
@@ -174,6 +180,9 @@ class MeshtasticPlatform extends BasePlatform {
 
     conn.on('disconnected', (info) => {
       if (this._disconnecting) return;
+      if (this._transport === transport) {
+        this._transport = null;
+      }
       this.status = 'disconnected';
       this.emit('disconnected', { reason: info?.reason || 'device_disconnected' });
       this._scheduleReconnect();

package/server/services/messaging/meshtastic_env.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const fs = require('fs');
-const path = require('path');
 const { ENV_FILE } = require('../../../runtime/paths');
 const { parseEnv } = require('../../../runtime/env');
 
@@ -20,41 +19,6 @@ function readEnvFileRaw(envFile = ENV_FILE) {
   return fs.readFileSync(envFile, 'utf8');
 }
 
-function writeEnvFileValue(key, value, envFile = ENV_FILE) {
-  const raw = readEnvFileRaw(envFile);
-  const lines = raw ? raw.split('\n') : [];
-  let replaced = false;
-
-  for (let i = 0; i < lines.length; i += 1) {
-    if (lines[i].startsWith(`${key}=`)) {
-      lines[i] = `${key}=${value}`;
-      replaced = true;
-      break;
-    }
-  }
-
-  if (!replaced) {
-    lines.push(`${key}=${value}`);
-  }
-
-  const output = `${lines
-    .filter((_, idx, items) => idx !== items.length - 1 || items[idx] !== '')
-    .join('\n')}\n`;
-  fs.mkdirSync(path.dirname(envFile), { recursive: true });
-  fs.writeFileSync(envFile, output, { mode: 0o600 });
-}
-
-function removeEnvFileValue(key, envFile = ENV_FILE) {
-  const raw = readEnvFileRaw(envFile);
-  if (!raw) return false;
-  const lines = raw.split('\n').filter((line) => !line.startsWith(`${key}=`));
-  const output = `${lines
-    .filter((_, idx, items) => idx !== items.length - 1 || items[idx] !== '')
-    .join('\n')}\n`;
-  fs.mkdirSync(path.dirname(envFile), { recursive: true });
-  fs.writeFileSync(envFile, output, { mode: 0o600 });
-  return true;
-}
 
 function readMeshtasticEnabled({
   env = process.env,
@@ -69,32 +33,8 @@ function readMeshtasticEnabled({
   return normalizeMeshtasticEnabled(parsed.get(MESHTASTIC_ENABLED_ENV_KEY), fallback);
 }
 
-function setMeshtasticEnabled(enabled, {
-  env = process.env,
-  envFile = ENV_FILE,
-} = {}) {
-  const normalized = normalizeMeshtasticEnabled(enabled, true);
-  writeEnvFileValue(MESHTASTIC_ENABLED_ENV_KEY, normalized ? 'true' : 'false', envFile);
-  if (env && typeof env === 'object') {
-    env[MESHTASTIC_ENABLED_ENV_KEY] = normalized ? 'true' : 'false';
-  }
-  return normalized;
-}
-
-function resetMeshtasticEnabled({
-  env = process.env,
-  envFile = ENV_FILE,
-} = {}) {
-  removeEnvFileValue(MESHTASTIC_ENABLED_ENV_KEY, envFile);
-  if (env && typeof env === 'object') {
-    delete env[MESHTASTIC_ENABLED_ENV_KEY];
-  }
-}
-
 module.exports = {
   MESHTASTIC_ENABLED_ENV_KEY,
   normalizeMeshtasticEnabled,
   readMeshtasticEnabled,
-  setMeshtasticEnabled,
-  resetMeshtasticEnabled,
 };

package/server/services/messaging/meshtastic_protocol.js

@@ -314,36 +314,63 @@ class MeshtasticConnection extends EventEmitter {
     return new Promise((resolve, reject) => {
       const socket = new Socket();
       let settled = false;
+      let timer = null;
+
+      const cleanupHandshake = () => {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        socket.removeListener('error', fail);
+        socket.removeListener('close', onPreReadyClose);
+        this.removeListener('configured', onConfigured);
+        this.removeListener('disconnected', onDisconnected);
+      };
 
       const fail = (err) => {
         if (settled) return;
         settled = true;
+        cleanupHandshake();
+        if (this._socket === socket) {
+          this._socket = null;
+        }
         socket.destroy();
         reject(err);
       };
 
-      const timer = setTimeout(() => fail(new Error('Connection timeout')), timeout);
+      const onConfigured = () => {
+        if (settled) return;
+        settled = true;
+        cleanupHandshake();
+        resolve();
+      };
+
+      const onDisconnected = (info) => {
+        fail(new Error(`Disconnected before configuration: ${info?.reason || 'unknown'}`));
+      };
+
+      const onPreReadyClose = () => {
+        fail(new Error('Disconnected before configuration: socket-closed'));
+      };
+
+      timer = setTimeout(() => fail(new Error('Connection timeout')), timeout);
 
       socket.once('error', fail);
+      socket.once('close', onPreReadyClose);
       socket.once('ready', () => {
         socket.removeListener('error', fail);
+        socket.removeListener('close', onPreReadyClose);
         this._socket = socket;
         this._wireSocket(socket);
         this.emit('status', 'connected');
 
-        const onConfigured = () => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          resolve();
-        };
         this.once('configured', onConfigured);
+        this.once('disconnected', onDisconnected);
 
         const toRadio = encodeToRadioWantConfig(this._configId);
         socket.write(framePacket(toRadio));
       });
 
-      socket.setTimeout(timeout);
       socket.connect(port, host);
     });
   }
@@ -361,18 +388,22 @@ class MeshtasticConnection extends EventEmitter {
     });
 
     socket.on('data', parser);
-    socket.on('error', (err) => this._onDisconnected(`socket-error: ${err.message}`))
+    socket.on('error', (err) => this._onDisconnected(`socket-error: ${err.message}`));
     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;
+    const socket = this._socket;
+    if (!socket) return;
+    this._socket = null;
     this._configured = false;
+    socket.removeAllListeners();
+    socket.destroy();
     this.emit('status', 'disconnected');
     this.emit('disconnected', { reason });
   }