neoagent 2.4.1-beta.9 → 2.4.1

package/server/services/ai/tools.js

@@ -274,6 +274,42 @@ function markProactiveMessageSent({ runState, deliveryState, content }) {
     }
 }
 
+function markProactiveNoResponse({ runState, deliveryState }) {
+    if (runState) {
+        runState.noResponse = true;
+    }
+    if (deliveryState) {
+        deliveryState.noResponse = true;
+    }
+}
+
+function normalizeStoredSettingString(value) {
+    if (value == null) return '';
+    if (typeof value !== 'string') return String(value || '').trim();
+    let current = value.trim();
+    for (let i = 0; i < 2; i += 1) {
+        if (!current) return '';
+        try {
+            const parsed = JSON.parse(current);
+            if (typeof parsed === 'string') {
+                current = parsed.trim();
+                continue;
+            }
+            return '';
+        } catch {
+            return current;
+        }
+    }
+    return current;
+}
+
+function normalizeMessagingTarget(target = {}) {
+    const platform = normalizeStoredSettingString(target.platform);
+    const to = normalizeStoredSettingString(target.to);
+    if (!platform || !to) return null;
+    return { platform, to };
+}
+
 function buildAndroidUiMatchProperties(extra = {}) {
     return {
         x: { type: 'number', description: 'Absolute X coordinate' },
@@ -1289,7 +1325,7 @@ function getAvailableTools(app, options = {}) {
     // mechanism and gives the AI real agency over when it's finished.
     tools.push({
         name: 'task_complete',
-        description: 'Signal that the task is fully complete and provide the final response. Call this exactly once when all steps are done and you have a complete answer ready. Do NOT call it if you still have work to do.',
+        description: 'Signal that the task is fully complete and provide the final response. Call this exactly once when all steps are done and you have a complete answer ready. Do NOT call it if you still have work to do, unverified claims, unresolved tool failures, or confidence below the current run requirement.',
         parameters: {
             type: 'object',
             properties: {
@@ -1300,10 +1336,10 @@ function getAvailableTools(app, options = {}) {
                 confidence: {
                     type: 'string',
                     enum: ['high', 'medium', 'low'],
-                    description: 'How confident are you the task is fully and correctly complete? Use "low" if you had to make assumptions.'
+                    description: 'How confident are you the task is fully and correctly complete? Use "low" only when the final answer is intentionally limited or incomplete; low confidence may be rejected so the run can keep working.'
                 }
             },
-            required: ['message']
+            required: ['message', 'confidence']
         }
     });
 
@@ -2112,6 +2148,9 @@ async function executeTool(toolName, args, context, engine) {
                             error: proactiveValidation.error,
                         };
                     }
+                    if (proactiveValidation.reason === 'no_response') {
+                        markProactiveNoResponse({ runState, deliveryState });
+                    }
                     return {
                         sent: false,
                         suppressed: proactiveValidation.suppressed === true,
@@ -2323,8 +2362,8 @@ async function executeTool(toolName, args, context, engine) {
                     || null
                 );
                 const loadDefaultTarget = () => ({
-                    platform: loadAgentSetting('last_platform'),
-                    to: loadAgentSetting('last_chat_id')
+                    platform: normalizeStoredSettingString(loadAgentSetting('last_platform')),
+                    to: normalizeStoredSettingString(loadAgentSetting('last_chat_id'))
                 });
 
                 let taskConfig = null;
@@ -2336,26 +2375,43 @@ async function executeTool(toolName, args, context, engine) {
                         try {
                             taskConfig = JSON.parse(task.task_config || '{}');
                             taskTarget = {
-                                platform: taskConfig.notifyPlatform || null,
-                                to: taskConfig.notifyTo || null
+                                platform: normalizeStoredSettingString(taskConfig.notifyPlatform),
+                                to: normalizeStoredSettingString(taskConfig.notifyTo)
                             };
                         } catch { }
                     }
                 }
 
                 const fallbackTarget = loadDefaultTarget();
+                const recentTargets = db.prepare(
+                    `SELECT platform, platform_chat_id
+                     FROM messages
+                     WHERE user_id = ?
+                       AND agent_id = ?
+                       AND platform IS NOT NULL
+                       AND platform_chat_id IS NOT NULL
+                     ORDER BY id DESC
+                     LIMIT 20`
+                ).all(userId, agentId);
                 const candidateTargets = [];
                 const seenTargets = new Set();
                 const addCandidate = (target) => {
-                    if (!target?.platform || !target?.to) return;
-                    const key = `${target.platform}:${target.to}`;
+                    const normalizedTarget = normalizeMessagingTarget(target);
+                    if (!normalizedTarget) return;
+                    const key = `${normalizedTarget.platform}:${normalizedTarget.to}`;
                     if (seenTargets.has(key)) return;
                     seenTargets.add(key);
-                    candidateTargets.push(target);
+                    candidateTargets.push(normalizedTarget);
                 };
 
                 addCandidate(taskTarget);
                 addCandidate(fallbackTarget);
+                for (const row of recentTargets) {
+                    addCandidate({
+                        platform: row.platform,
+                        to: row.platform_chat_id
+                    });
+                }
 
                 if (candidateTargets.length === 0) {
                     throw new Error('No messaging target is configured for this task run. Connect a platform and send at least one message on this server, or recreate the task after reconnecting.');
@@ -2611,8 +2667,14 @@ async function executeTool(toolName, args, context, engine) {
                 let tools = [];
                 if (autoStart) {
                     try {
-                        await mcpClient.startServer(serverId, args.command, args.name, userId, { agentId });
-                        tools = await mcpClient.listTools(serverId, userId);
+                        const startResult = await mcpClient.startServer(
+                            serverId,
+                            args.command,
+                            args.name,
+                            userId,
+                            { agentId }
+                        );
+                        tools = startResult.tools || [];
                     } catch (startErr) {
                         return { registered: true, id: serverId, started: false, error: `Registered but failed to start: ${startErr.message}` };
                     }
@@ -2635,7 +2697,10 @@ async function executeTool(toolName, args, context, engine) {
                     args: JSON.parse(s.config || '{}').args || [],
                     enabled: !!s.enabled,
                     status: liveStatuses[s.id]?.status || 'stopped',
-                    toolCount: liveStatuses[s.id]?.toolCount || 0
+                    toolCount: liveStatuses[s.id]?.toolCount || 0,
+                    error: liveStatuses[s.id]?.error || null,
+                    consecutiveFails: liveStatuses[s.id]?.consecutiveFails || 0,
+                    nextRetryAt: liveStatuses[s.id]?.nextRetryAt || null
                 }))
             };
         }

package/server/services/browser/extension/registry.js

@@ -10,6 +10,7 @@ const DEFAULT_PAIRING_TTL_MS = 10 * 60 * 1000;
 const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 1000;
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 25 * 1000;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 75 * 1000;
+const DEFAULT_PRESENCE_TOUCH_INTERVAL_MS = 15 * 1000;
 
 function sha256(value) {
   return crypto.createHash('sha256').update(String(value || '')).digest('hex');
@@ -46,6 +47,7 @@ class BrowserExtensionRegistry {
     this.pairingTtlMs = Number(options.pairingTtlMs || process.env.NEOAGENT_BROWSER_EXTENSION_PAIRING_TTL_MS || DEFAULT_PAIRING_TTL_MS);
     this.heartbeatIntervalMs = Number(options.heartbeatIntervalMs || process.env.NEOAGENT_BROWSER_EXTENSION_HEARTBEAT_INTERVAL_MS || DEFAULT_HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimeoutMs = Number(options.heartbeatTimeoutMs || process.env.NEOAGENT_BROWSER_EXTENSION_HEARTBEAT_TIMEOUT_MS || DEFAULT_HEARTBEAT_TIMEOUT_MS);
+    this.presenceTouchIntervalMs = Number(options.presenceTouchIntervalMs || process.env.NEOAGENT_BROWSER_EXTENSION_PRESENCE_TOUCH_INTERVAL_MS || DEFAULT_PRESENCE_TOUCH_INTERVAL_MS);
     this.connectionsByUser = new Map();
   }
 
@@ -142,16 +144,42 @@ class BrowserExtensionRegistry {
     };
 
     const tx = this.db.transaction(() => {
+      // Find other active tokens with the same name for this user.
+      // If they are currently offline, revoke them to clean up old installs/duplicates.
+      const duplicates = this.db.prepare(
+        `SELECT id FROM browser_extension_tokens
+         WHERE user_id = ? AND name = ? AND status = 'active'`
+      ).all(row.user_id, extensionName);
+
+      for (const dup of duplicates) {
+        if (!this.isConnected(row.user_id, dup.id)) {
+          this.db.prepare(
+            `UPDATE browser_extension_tokens
+             SET status = 'revoked', revoked_at = datetime('now')
+             WHERE id = ?`
+          ).run(dup.id);
+        }
+      }
+
       this.db.prepare(
         `UPDATE browser_extension_pairing_requests
          SET status = 'claimed', claimed_at = datetime('now')
          WHERE id = ?`
       ).run(row.id);
+      
       this.db.prepare(
         `INSERT INTO browser_extension_tokens (
            id, user_id, token_hash, name, status, metadata_json
          ) VALUES (?, ?, ?, ?, 'active', ?)`
       ).run(tokenId, row.user_id, sha256(token), extensionName, safeJson(metadata));
+
+      // Auto-select the newly paired token on claim
+      const write = this.db.prepare(
+        `INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?)
+         ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value`
+      );
+      write.run(row.user_id, 'browser_extension_token_id', tokenId);
+      write.run(row.user_id, 'selected_browser_extension_token_id', tokenId);
     });
     tx();
 
@@ -192,6 +220,7 @@ class BrowserExtensionRegistry {
       timeoutMs: this.commandTimeoutMs,
       heartbeatIntervalMs: this.heartbeatIntervalMs,
       heartbeatTimeoutMs: this.heartbeatTimeoutMs,
+      presenceTouchIntervalMs: this.presenceTouchIntervalMs,
     });
     userMap.set(tokenRow.id, connection);
     this.db.prepare(
@@ -260,17 +289,44 @@ class BrowserExtensionRegistry {
     if (selected && userMap.get(selected)?.isOpen()) {
       return userMap.get(selected);
     }
-    if (selected) return null;
+
+    // Auto-select online connection if selected is offline/unset
     const online = Array.from(userMap.values()).filter((connection) => connection.isOpen());
-    if (online.length === 0) return null;
-    online.sort((a, b) => String(b.connectedAt || '').localeCompare(String(a.connectedAt || '')));
-    return online[0];
+    if (online.length > 0) {
+      online.sort((a, b) => String(b.connectedAt || '').localeCompare(String(a.connectedAt || '')));
+      const activeConnection = online[0];
+      try {
+        const write = this.db.prepare(
+          `INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?)
+           ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value`
+        );
+        write.run(userId, 'browser_extension_token_id', activeConnection.tokenId);
+        write.run(userId, 'selected_browser_extension_token_id', activeConnection.tokenId);
+      } catch (err) {
+        console.error('[Registry] failed to auto-select online extension', err);
+      }
+      return activeConnection;
+    }
+
+    if (selected) {
+      return userMap.get(selected) || null;
+    }
+    return null;
   }
 
   isConnected(userId, tokenId = null) {
     return Boolean(this.getConnection(userId, tokenId)?.isOpen());
   }
 
+  touchPresence(userId, tokenId) {
+    const userMap = this.#getUserConnections(userId);
+    const connection = userMap?.get(String(tokenId));
+    if (!connection?.isOpen()) return;
+    this.db.prepare(
+      `UPDATE browser_extension_tokens SET last_seen_at = datetime('now') WHERE id = ?`
+    ).run(tokenId);
+  }
+
   async dispatch(userId, command, payload = {}, options = {}) {
     const connection = this.getConnection(userId, options.tokenId || payload.tokenId || null);
     if (!connection || !connection.isOpen()) {
@@ -285,10 +341,16 @@ class BrowserExtensionRegistry {
 
   getStatus(userId) {
     const userMap = this.#getUserConnections(userId);
-    const selectedTokenId = this.getSelectedTokenId(userId);
-    const connected = selectedTokenId
+    let selectedTokenId = this.getSelectedTokenId(userId);
+    let connected = selectedTokenId
       ? userMap?.get(selectedTokenId)
-      : this.getConnection(userId);
+      : null;
+    if (!connected?.isOpen()) {
+      connected = this.getConnection(userId);
+      if (connected?.isOpen()) {
+        selectedTokenId = connected.tokenId;
+      }
+    }
     const effectiveSelectedTokenId = selectedTokenId || connected?.tokenId || null;
     const tokens = this.db.prepare(
       `SELECT id, name, status, last_connected_at, last_seen_at, revoked_at, created_at, metadata_json
@@ -356,7 +418,7 @@ class BrowserExtensionRegistry {
 }
 
 class ExtensionBrowserConnection {
-  constructor({ registry, ws, userId, tokenId, meta, timeoutMs, heartbeatIntervalMs, heartbeatTimeoutMs }) {
+  constructor({ registry, ws, userId, tokenId, meta, timeoutMs, heartbeatIntervalMs, heartbeatTimeoutMs, presenceTouchIntervalMs }) {
     this.registry = registry;
     this.ws = ws;
     this.userId = userId;
@@ -365,13 +427,18 @@ class ExtensionBrowserConnection {
     this.timeoutMs = timeoutMs;
     this.heartbeatIntervalMs = heartbeatIntervalMs;
     this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+    this.presenceTouchIntervalMs = presenceTouchIntervalMs;
     this.pending = new Map();
     this.connectedAt = new Date().toISOString();
     this.lastPongAt = Date.now();
+    this.lastPresenceTouchAt = 0;
     this.heartbeatTimer = null;
 
     ws.on('message', (data) => this.#handleMessage(data));
-    ws.on('pong', () => { this.lastPongAt = Date.now(); });
+    ws.on('pong', () => {
+      this.lastPongAt = Date.now();
+      this.touchPresence();
+    });
     ws.on('close', () => this.#closePending(new ExtensionBrowserUnavailableError('Extension browser disconnected.')));
     ws.on('error', (error) => this.#closePending(error));
     this.#startHeartbeat();
@@ -391,6 +458,21 @@ class ExtensionBrowserConnection {
     this.#closePending(new ExtensionBrowserUnavailableError('Extension browser disconnected.'));
   }
 
+  touchPresence({ force = false } = {}) {
+    const now = Date.now();
+    const intervalMs = Number(this.presenceTouchIntervalMs);
+    if (
+      !force
+      && Number.isFinite(intervalMs)
+      && intervalMs > 0
+      && now - this.lastPresenceTouchAt < intervalMs
+    ) {
+      return;
+    }
+    this.lastPresenceTouchAt = now;
+    this.registry.touchPresence(this.userId, this.tokenId);
+  }
+
   sendCommand(command, payload = {}, options = {}) {
     if (!this.isOpen()) {
       return Promise.reject(new ExtensionBrowserUnavailableError());
@@ -416,6 +498,7 @@ class ExtensionBrowserConnection {
 
   #handleMessage(data) {
     this.lastPongAt = Date.now();
+    this.touchPresence();
     let message;
     try {
       message = parseExtensionMessage(data);
@@ -453,6 +536,7 @@ class ExtensionBrowserConnection {
     const intervalMs = Number(this.heartbeatIntervalMs);
     const timeoutMs = Number(this.heartbeatTimeoutMs);
     if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+    this.touchPresence({ force: true });
     this.heartbeatTimer = setInterval(() => {
       if (!this.isOpen()) {
         this.#closePending(new ExtensionBrowserUnavailableError('Extension browser disconnected.'));
@@ -463,6 +547,7 @@ class ExtensionBrowserConnection {
         this.#closePending(new ExtensionBrowserUnavailableError('Extension browser heartbeat timed out.'));
         return;
       }
+      this.touchPresence();
       try {
         this.ws.ping();
       } catch (error) {

package/server/services/desktop/registry.js

@@ -10,6 +10,9 @@ const {
 } = require('./protocol');
 
 const DEFAULT_COMMAND_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 25 * 1000;
+const DEFAULT_HEARTBEAT_TIMEOUT_MS = 75 * 1000;
+const DEFAULT_PRESENCE_TOUCH_INTERVAL_MS = 15 * 1000;
 
 function safeJson(value) {
   try {
@@ -47,6 +50,21 @@ class DesktopCompanionRegistry {
       || process.env.NEOAGENT_DESKTOP_COMMAND_TIMEOUT_MS
       || DEFAULT_COMMAND_TIMEOUT_MS,
     );
+    this.heartbeatIntervalMs = Number(
+      options.heartbeatIntervalMs
+      || process.env.NEOAGENT_DESKTOP_HEARTBEAT_INTERVAL_MS
+      || DEFAULT_HEARTBEAT_INTERVAL_MS,
+    );
+    this.heartbeatTimeoutMs = Number(
+      options.heartbeatTimeoutMs
+      || process.env.NEOAGENT_DESKTOP_HEARTBEAT_TIMEOUT_MS
+      || DEFAULT_HEARTBEAT_TIMEOUT_MS,
+    );
+    this.presenceTouchIntervalMs = Number(
+      options.presenceTouchIntervalMs
+      || process.env.NEOAGENT_DESKTOP_PRESENCE_TOUCH_INTERVAL_MS
+      || DEFAULT_PRESENCE_TOUCH_INTERVAL_MS,
+    );
     this.connectionsByUser = new Map();
   }
 
@@ -200,6 +218,9 @@ class DesktopCompanionRegistry {
         platform: record.platform,
       },
       timeoutMs: this.commandTimeoutMs,
+      heartbeatIntervalMs: this.heartbeatIntervalMs,
+      heartbeatTimeoutMs: this.heartbeatTimeoutMs,
+      presenceTouchIntervalMs: this.presenceTouchIntervalMs,
     });
     // Install the new connection in the map BEFORE closing the old one.
     // This ensures that when the old socket's async 'close' event fires and
@@ -275,6 +296,19 @@ class DesktopCompanionRegistry {
     return this.getDeviceRecordByDeviceId(userId, deviceId);
   }
 
+  touchPresence(userId, deviceId) {
+    const userMap = this._getUserMap(userId);
+    const connection = userMap?.get(String(deviceId));
+    if (!connection?.isOpen()) return;
+    this.db.prepare(
+      `UPDATE desktop_companion_devices
+       SET status = 'online',
+           last_seen_at = datetime('now'),
+           updated_at = datetime('now')
+       WHERE user_id = ? AND device_id = ? AND revoked_at IS NULL`
+    ).run(userId, deviceId);
+  }
+
   isConnected(userId) {
     const userMap = this._getUserMap(userId);
     return userMap != null && userMap.size > 0;
@@ -493,7 +527,19 @@ class DesktopCompanionRegistry {
 }
 
 class DesktopCompanionConnection {
-  constructor({ registry, ws, userId, sessionId, deviceId, recordId, meta, timeoutMs }) {
+  constructor({
+    registry,
+    ws,
+    userId,
+    sessionId,
+    deviceId,
+    recordId,
+    meta,
+    timeoutMs,
+    heartbeatIntervalMs,
+    heartbeatTimeoutMs,
+    presenceTouchIntervalMs,
+  }) {
     this.registry = registry;
     this.ws = ws;
     this.userId = userId;
@@ -502,11 +548,22 @@ class DesktopCompanionConnection {
     this.recordId = recordId;
     this.meta = meta || {};
     this.timeoutMs = timeoutMs;
+    this.heartbeatIntervalMs = heartbeatIntervalMs;
+    this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+    this.presenceTouchIntervalMs = presenceTouchIntervalMs;
     this.pending = new Map();
+    this.lastPongAt = Date.now();
+    this.lastPresenceTouchAt = 0;
+    this.heartbeatTimer = null;
 
     ws.on('message', (data) => this._handleMessage(data));
+    ws.on('pong', () => {
+      this.lastPongAt = Date.now();
+      this.touchPresence();
+    });
     ws.on('close', () => this._closePending(new DesktopCompanionUnavailableError('Desktop companion disconnected.')));
     ws.on('error', (error) => this._closePending(error));
+    this._startHeartbeat();
   }
 
   isOpen() {
@@ -525,6 +582,21 @@ class DesktopCompanionConnection {
     this._closePending(new DesktopCompanionUnavailableError('Desktop companion disconnected.'));
   }
 
+  touchPresence({ force = false } = {}) {
+    const now = Date.now();
+    const intervalMs = Number(this.presenceTouchIntervalMs);
+    if (
+      !force
+      && Number.isFinite(intervalMs)
+      && intervalMs > 0
+      && now - this.lastPresenceTouchAt < intervalMs
+    ) {
+      return;
+    }
+    this.lastPresenceTouchAt = now;
+    this.registry.touchPresence(this.userId, this.deviceId);
+  }
+
   sendCommand(command, payload = {}, options = {}) {
     if (!this.isOpen()) {
       return Promise.reject(new DesktopCompanionUnavailableError());
@@ -549,6 +621,8 @@ class DesktopCompanionConnection {
   }
 
   _handleMessage(data) {
+    this.lastPongAt = Date.now();
+    this.touchPresence();
     if (Buffer.isBuffer(data) && data.length > 0 && data[0] === FRAME_TYPE_VIDEO) {
       return;
     }
@@ -585,6 +659,10 @@ class DesktopCompanionConnection {
   }
 
   _closePending(error) {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
       pending.reject(error);
@@ -596,6 +674,31 @@ class DesktopCompanionConnection {
     // mark the device offline.
     this.registry.unregisterConnection(this);
   }
+
+  _startHeartbeat() {
+    const intervalMs = Number(this.heartbeatIntervalMs);
+    const timeoutMs = Number(this.heartbeatTimeoutMs);
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+    this.touchPresence({ force: true });
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isOpen()) {
+        this._closePending(new DesktopCompanionUnavailableError('Desktop companion disconnected.'));
+        return;
+      }
+      if (Number.isFinite(timeoutMs) && timeoutMs > 0 && Date.now() - this.lastPongAt > timeoutMs) {
+        try { this.ws.terminate(); } catch {}
+        this._closePending(new DesktopCompanionUnavailableError('Desktop companion heartbeat timed out.'));
+        return;
+      }
+      this.touchPresence();
+      try {
+        this.ws.ping();
+      } catch (error) {
+        this._closePending(error);
+      }
+    }, intervalMs);
+    this.heartbeatTimer.unref?.();
+  }
 }
 
 module.exports = {