neoagent 2.3.1-beta.4 → 2.3.1-beta.41

package/server/services/ai/tools.js

@@ -192,6 +192,54 @@ function isProactiveTrigger(triggerSource) {
     return triggerSource === 'schedule' || triggerSource === 'tasks';
 }
 
+function normalizeSendMessagePurpose(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'final_result' || normalized === 'blocker' || normalized === 'no_response') {
+        return normalized;
+    }
+    return '';
+}
+
+function validateProactiveSendMessageArgs({ purpose, normalizedMessage }) {
+    const normalizedPurpose = normalizeSendMessagePurpose(purpose);
+    if (!normalizedPurpose) {
+        return {
+            ok: false,
+            error: 'Background send_message requires purpose=final_result, blocker, or no_response.',
+            reason: 'Background send_message requires purpose=final_result, blocker, or no_response.',
+        };
+    }
+
+    if (normalizedPurpose === 'no_response') {
+        if (normalizedMessage !== '[NO RESPONSE]') {
+            return {
+                ok: false,
+                error: 'purpose=no_response requires content "[NO RESPONSE]".',
+                reason: 'purpose=no_response requires content "[NO RESPONSE]".',
+            };
+        }
+        return {
+            ok: false,
+            skipped: true,
+            suppressed: true,
+            reason: 'no_response',
+        };
+    }
+
+    if (normalizedMessage === '[NO RESPONSE]') {
+        return {
+            ok: false,
+            error: `purpose=${normalizedPurpose} cannot use content "[NO RESPONSE]".`,
+            reason: `purpose=${normalizedPurpose} cannot use content "[NO RESPONSE]".`,
+        };
+    }
+
+    return {
+        ok: true,
+        purpose: normalizedPurpose,
+    };
+}
+
 function getRunState(engine, runId) {
     if (!engine || !runId) return null;
     return engine.activeRuns.get(runId) || null;
@@ -742,14 +790,15 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'send_message',
-            description: `Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, Telegram, Slack, Google Chat, Microsoft Teams, Matrix, Signal, iMessage/BlueBubbles, IRC, Feishu, LINE, Mattermost, Nextcloud Talk, Nostr, Synology Chat, Tlon, Twitch, Zalo, WeChat, WebChat, and configurable webhook bridges. ${buildSendMessageFormattingReference()} For WhatsApp: use media_path to attach files. Use content "[NO RESPONSE]" only when the user explicitly asked for silence or no reply.`,
+            description: `Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, Telegram, Slack, Google Chat, Microsoft Teams, Matrix, Signal, iMessage/BlueBubbles, IRC, Feishu, LINE, Mattermost, Nextcloud Talk, Nostr, Synology Chat, Tlon, Twitch, Zalo, WeChat, WebChat, and configurable webhook bridges. ${buildSendMessageFormattingReference()} For WhatsApp: use media_path to attach files. Use content "[NO RESPONSE]" only when the user explicitly asked for silence or no reply. For background task or schedule runs, set purpose to final_result, blocker, or no_response.`,
             parameters: {
                 type: 'object',
                 properties: {
                     platform: { type: 'string', description: 'Platform name, for example whatsapp, telnyx, discord, telegram, slack, google_chat, teams, matrix, signal, imessage, bluebubbles, irc, line, mattermost, or webchat' },
                     to: { type: 'string', description: 'Recipient/chat ID for the connected platform, such as a WhatsApp chat ID, Telnyx call_control_id, Slack channel ID, Matrix room ID, Discord channel snowflake / "dm_<userId>", Telegram "dm_<userId>" / raw group chat ID, IRC channel, or webhook target' },
                     content: { type: 'string', description: 'Message text. Write one compact natural chat reply; the runtime adapts final formatting for the destination platform.' },
-                    media_path: { type: 'string', description: 'WhatsApp only: absolute path to a local file to attach. Leave empty for text-only or Telnyx.' }
+                    media_path: { type: 'string', description: 'WhatsApp only: absolute path to a local file to attach. Leave empty for text-only or Telnyx.' },
+                    purpose: { type: 'string', enum: ['final_result', 'blocker', 'no_response'], description: 'For background task or schedule runs, required intent for this outbound message. Use final_result for a concrete useful outcome, blocker for a real issue the user should know about, or no_response to intentionally send nothing.' }
                 },
                 required: ['platform', 'to', 'content']
             }
@@ -1986,6 +2035,25 @@ async function executeTool(toolName, args, context, engine) {
                 stripNoResponseMarker: false
             });
             const suppressReply = normalizedMessage === '[NO RESPONSE]';
+            if (isProactiveTrigger(triggerSource)) {
+                const proactiveValidation = validateProactiveSendMessageArgs({
+                    purpose: args.purpose,
+                    normalizedMessage,
+                });
+                if (!proactiveValidation.ok) {
+                    if (proactiveValidation.error) {
+                        return {
+                            error: proactiveValidation.error,
+                        };
+                    }
+                    return {
+                        sent: false,
+                        suppressed: proactiveValidation.suppressed === true,
+                        skipped: proactiveValidation.skipped === true,
+                        reason: proactiveValidation.reason,
+                    };
+                }
+            }
             if (!suppressReply && hasAlreadySentProactiveMessage({
                 triggerSource,
                 runState,
@@ -2676,7 +2744,12 @@ async function executeTool(toolName, args, context, engine) {
             const { detectPromptInjection } = require('../../utils/security');
             const mcpManager = mcp();
             if (mcpManager) {
-                const mcpResult = await mcpManager.callToolByName(toolName, args, userId, { agentId });
+                let mcpResult = null;
+                try {
+                    mcpResult = await mcpManager.callToolByName(toolName, args, userId, { agentId });
+                } catch (mcpErr) {
+                    return { error: mcpErr.message, tool: toolName, source: 'mcp' };
+                }
                 if (mcpResult !== null) {
                     const resultText = typeof mcpResult === 'string' ? mcpResult : JSON.stringify(mcpResult);
                     if (detectPromptInjection(resultText)) {
@@ -2701,4 +2774,4 @@ async function executeTool(toolName, args, context, engine) {
     }
 }
 
-module.exports = { getAvailableTools, executeTool };
+module.exports = { getAvailableTools, executeTool, validateProactiveSendMessageArgs };

package/server/services/desktop/screenRecorder.js

@@ -12,16 +12,52 @@ const { getErrorMessage } = require('../bootstrap_helpers');
 const execAsync = promisify(exec);
 
 class ScreenRecorder {
-  constructor() {
+  constructor(options = {}) {
     this.intervalMs = 10000; // 10 seconds
     this.intervalId = null;
     this.cleanupIntervalId = null;
     this.isRecording = false;
     this.isProcessing = false;
     this.tempFilePath = path.join(os.tmpdir(), `neoagent-screen-${Date.now()}.png`);
+    this.lastBenignSkipAt = 0;
+    this.hasActiveRemoteCaptureSession = typeof options.hasActiveRemoteCaptureSession === 'function'
+      ? options.hasActiveRemoteCaptureSession
+      : () => false;
+  }
+
+  _isCaptureInactiveApp(appName) {
+    const normalized = String(appName || '').trim().toLowerCase();
+    return normalized === '' || normalized === 'loginwindow' || normalized === 'screensaverengine';
+  }
+
+  _isBenignCaptureError(message) {
+    const text = String(message || '').toLowerCase();
+    return (
+      text.includes('operation not permitted') ||
+      text.includes('not authorized') ||
+      text.includes('user canceled') ||
+      text.includes('cgwindowlistcreateimage') ||
+      text.includes('screencapture') ||
+      text.includes('timed out')
+    );
+  }
+
+  _logBenignSkip(reason) {
+    const now = Date.now();
+    if (now - this.lastBenignSkipAt < 5 * 60 * 1000) {
+      return;
+    }
+    this.lastBenignSkipAt = now;
+    console.log(`[ScreenRecorder] Capture skipped: ${reason}`);
   }
 
   start() {
+    const enabledEnv = String(process.env.NEOAGENT_SCREEN_RECORDER_ENABLED || '').trim().toLowerCase();
+    if (enabledEnv === '0' || enabledEnv === 'false' || enabledEnv === 'off' || enabledEnv === 'no') {
+      console.log('[ScreenRecorder] Not starting: disabled by NEOAGENT_SCREEN_RECORDER_ENABLED.');
+      return;
+    }
+
     if (process.platform !== 'darwin') {
       console.log('[ScreenRecorder] Not starting: Screen recording is currently macOS only.');
       return;
@@ -61,6 +97,27 @@ class ScreenRecorder {
     this.isProcessing = true;
 
     try {
+      // Only capture while at least one external device/session is actively connected.
+      // This prevents host-level screenshots when no user-side capture source is live.
+      if (!this.hasActiveRemoteCaptureSession()) {
+        this._logBenignSkip('no active external capture session');
+        return;
+      }
+
+      // Skip capture when the desktop session is inactive (e.g. locked screen).
+      let frontmostApp = '';
+      try {
+        const { stdout } = await execAsync(`osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`);
+        frontmostApp = (stdout || '').trim();
+      } catch {
+        frontmostApp = '';
+      }
+
+      if (this._isCaptureInactiveApp(frontmostApp)) {
+        this._logBenignSkip('no active frontmost app');
+        return;
+      }
+
       // Capture screen silently (-x) to file
       await execAsync(`screencapture -x "${this.tempFilePath}"`);
 
@@ -80,13 +137,7 @@ class ScreenRecorder {
         const userRow = db.prepare('SELECT id FROM users ORDER BY id ASC LIMIT 1').get();
         if (userRow) {
           // Identify the active foreground app via AppleScript
-          let appName = 'Unknown';
-          try {
-            const { stdout } = await execAsync(`osascript -e 'tell application "System Events" to get name of first application process whose frontmost is true'`);
-            appName = stdout.trim();
-          } catch (e) {
-            // Ignore AppleScript errors
-          }
+          let appName = frontmostApp || 'Unknown';
 
           db.prepare(`
             INSERT INTO screen_history (user_id, app_name, text_content)
@@ -96,7 +147,12 @@ class ScreenRecorder {
       }
 
     } catch (err) {
-      console.error('[ScreenRecorder] Capture/OCR failed:', getErrorMessage(err));
+      const errorMessage = getErrorMessage(err);
+      if (this._isBenignCaptureError(errorMessage)) {
+        this._logBenignSkip(errorMessage);
+      } else {
+        console.error('[ScreenRecorder] Capture/OCR failed:', errorMessage);
+      }
     } finally {
       // Always cleanup the screenshot image immediately
       try {

package/server/services/integrations/env.js

@@ -68,6 +68,10 @@ function resolveSpotifyOAuthConfig() {
   return resolveOAuthConfig('SPOTIFY');
 }
 
+function resolveGithubOAuthConfig() {
+  return resolveOAuthConfig('GITHUB');
+}
+
 function describeEnvStatus(config, options = {}) {
   const label = String(options.label || 'This integration').trim() || 'This integration';
   if (config.configured) {
@@ -96,4 +100,5 @@ module.exports = {
   resolvePublicBaseUrl,
   resolveSpotifyOAuthConfig,
   resolveSlackOAuthConfig,
+  resolveGithubOAuthConfig,
 };

package/server/services/integrations/figma/provider.js

@@ -240,6 +240,7 @@ function createFigmaProvider() {
     description:
       'Official Figma OAuth account connections for future design file and collaboration workflows.',
     icon: 'figma',
+    requiresRefreshToken: true,
     apps: FIGMA_APPS,
     toolDefinitions: figmaToolDefinitions,
     connectPrompt:

package/server/services/integrations/github/common.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function base64UrlSha256(value) {
+  return crypto
+    .createHash('sha256')
+    .update(String(value || ''))
+    .digest('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+async function githubApiRequest(auth, options = {}) {
+  const {
+    method = 'GET',
+    path,
+    query = null,
+    body = null,
+    baseUrl = 'https://api.github.com',
+    token: overrideToken = '',
+  } = options;
+
+  const token = String(overrideToken || auth?.token || '').trim();
+  if (!token) {
+    throw new Error('GitHub authentication token is required for GitHub API requests.');
+  }
+
+  const url = new URL(path, baseUrl);
+  if (query && typeof query === 'object') {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== undefined && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+
+  const headers = {
+    'Accept': 'application/vnd.github.v3+json',
+    'Authorization': `Bearer ${token}`,
+    'X-GitHub-Api-Version': '2022-11-28',
+  };
+
+  if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  let data = null;
+  if (response.status !== 204 && response.status !== 205) {
+    const rawBody = await response.text();
+    if (rawBody.trim()) {
+      try {
+        data = JSON.parse(rawBody);
+      } catch {
+        if (!response.ok) {
+          const error = new Error(`GitHub API error ${response.status}: ${rawBody}`);
+          error.status = response.status;
+          error.data = rawBody;
+          throw error;
+        }
+        data = rawBody;
+      }
+    }
+  }
+
+  if (!response.ok) {
+    const errorMessage =
+      (data && typeof data === 'object' ? data.message : null) ||
+      `GitHub API error: ${response.status}`;
+    const error = new Error(errorMessage);
+    error.status = response.status;
+    error.data = data;
+    throw error;
+  }
+
+  return data;
+}
+
+function buildPaginationParams(options = {}) {
+  const params = {};
+  if (options.page) params.page = Number(options.page);
+  if (options.per_page) params.per_page = Math.min(Number(options.per_page) || 30, 100);
+  return params;
+}
+
+function parseOwnerRepo(ownerRepo) {
+  const parts = String(ownerRepo || '').split('/');
+  if (parts.length !== 2) {
+    throw new Error('owner_repo must be in format "owner/repo"');
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+
+module.exports = {
+  base64UrlSha256,
+  buildPaginationParams,
+  githubApiRequest,
+  parseOwnerRepo,
+};