neoagent 3.1.1-beta.2 → 3.1.1-beta.4

package/server/services/messaging/access_policy.js

@@ -37,7 +37,7 @@ const SHARED_RAW_ID_PLATFORMS = new Set([
   'webchat',
 ]);
 
-const DIRECT_ONLY_PHONE_PLATFORMS = new Set(['telnyx', 'whatsapp']);
+const DIRECT_ONLY_PHONE_PLATFORMS = new Set(['telnyx']);
 
 function capabilityTemplate(overrides = {}) {
   return Object.freeze({
@@ -300,6 +300,17 @@ function addRule(bucket, rule, state) {
   state[bucket].push(rule);
 }
 
+function isWhatsAppGroupId(value) {
+  return String(value || '').trim().toLowerCase().split(':')[0].endsWith('@g.us');
+}
+
+function normalizeWhatsAppDirectId(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  const base = raw.includes('@') ? raw.split('@')[0] : raw;
+  const primary = base.includes(':') ? base.split(':')[0] : base;
+  return primary.replace(/\D/g, '') || primary;
+}
+
 function migrateLegacyWhitelist(platform, entries) {
   const capabilities = getPlatformAccessCapabilities(platform);
   const policy = createDefaultAccessPolicy(platform);
@@ -328,6 +339,22 @@ function migrateLegacyWhitelist(platform, entries) {
     const value = sanitizeValue(scope || 'chat', rawValue);
     if (!value) continue;
 
+    if (platform === 'whatsapp') {
+      if (scope === 'group' || isWhatsAppGroupId(value)) {
+        addRule('sharedSpaceRules', normalizeRule({ scope: 'group', value }, new Set(capabilities.sharedSpaceRuleScopes)), state);
+        continue;
+      }
+      const directValue = scope === 'chat' ? value : normalizeWhatsAppDirectId(value);
+      if (!directValue) continue;
+      if (scope === 'chat') {
+        addRule('directRules', normalizeRule({ scope: 'chat', value: directValue }, new Set(capabilities.directRuleScopes)), state);
+      } else {
+        addRule('directRules', normalizeRule({ scope: 'phone_number', value: directValue }, new Set(capabilities.directRuleScopes)), state);
+        addRule('sharedActorRules', normalizeRule({ scope: 'phone_number', value: directValue }, new Set(capabilities.sharedActorRuleScopes)), state);
+      }
+      continue;
+    }
+
     if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform)) {
       addRule('directRules', normalizeRule({ scope: 'phone_number', value }, new Set(capabilities.directRuleScopes)), state);
       continue;
@@ -641,7 +668,17 @@ function classifyRecentTarget(platform, row) {
   if (!chatId && !sender) return null;
 
   const isDirect = !String(metadata.isGroup || '').match(/^(true|1)$/i) && (!chatId || chatId === sender || chatId === `dm_${sender}`);
-  if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform)) {
+  if (platform === 'whatsapp' && !isDirect && chatId) {
+    return {
+      source: 'recent',
+      bucket: 'sharedSpaceRules',
+      scope: 'group',
+      value: chatId,
+      label: groupName || chatId,
+      subtitle: 'Recent WhatsApp group',
+    };
+  }
+  if (DIRECT_ONLY_PHONE_PLATFORMS.has(platform) || platform === 'whatsapp') {
     const value = normalizePhone(sender || chatId);
     if (!value) return null;
     return {

package/server/services/messaging/manager.js

@@ -818,14 +818,19 @@ class MessagingManager extends EventEmitter {
     );
   }
 
-  async getAccessCatalog(userId, platformName, options = {}) {
+  async listAccessTargets(userId, platformName, options = {}) {
     const agentId = this._agentId(userId, options);
     const key = this._key(userId, agentId, platformName);
     const platform = this.platforms.get(key);
-    let discoveredTargets = [];
-    if (platform?.listAccessTargets) {
-      discoveredTargets = await Promise.resolve(platform.listAccessTargets()).catch(() => []);
+    if (!platform || typeof platform.listAccessTargets !== 'function') {
+      return [];
     }
+    return Promise.resolve(platform.listAccessTargets()).catch(() => []);
+  }
+
+  async getAccessCatalog(userId, platformName, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const discoveredTargets = await this.listAccessTargets(userId, platformName, { agentId });
 
     const recentRows = db.prepare(
       `SELECT platform_chat_id, metadata

package/server/services/public_status.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const db = require('../db/database');
+const { getRuntimeValidation } = require('./runtime/validation');
+
+function hasAnyAiProviderEnv() {
+  return [
+    'OPENAI_API_KEY',
+    'ANTHROPIC_API_KEY',
+    'GOOGLE_API_KEY',
+    'GEMINI_API_KEY',
+    'OPENROUTER_API_KEY',
+  ].some((name) => Boolean(String(process.env[name] || '').trim()));
+}
+
+function component(group, name, status, description) {
+  return { group, name, status, description };
+}
+
+function dbIsReachable() {
+  try {
+    db.prepare('SELECT 1 AS ok').get();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function overallStatus(components) {
+  if (components.some((item) => item.status === 'unavailable')) return 'unavailable';
+  if (components.some((item) => item.status === 'degraded')) return 'degraded';
+  return 'operational';
+}
+
+function buildPublicStatus(app) {
+  const runtimeValidation = getRuntimeValidation(app?.locals?.runtimeManager);
+  const runtimeReady = Boolean(runtimeValidation?.ready);
+  const storageReady = dbIsReachable();
+  const hasMessaging = Boolean(app?.locals?.messagingManager);
+  const hasIntegrations = Boolean(app?.locals?.integrationManager);
+  const hasMcp = Boolean(app?.locals?.mcpClient);
+  const hasDesktop = Boolean(app?.locals?.desktopCompanionRegistry || app?.locals?.desktopProvider);
+  const hasBrowser = Boolean(app?.locals?.browserExtensionRegistry || app?.locals?.browserController);
+  const hasMemory = Boolean(app?.locals?.memoryManager);
+  const hasAi = hasAnyAiProviderEnv();
+
+  const components = [
+    component('Core', 'Web App & API', 'operational', 'Requests are being served normally. Tiny victory parade withheld for focus.'),
+    component('Core', 'Accounts & Sessions', 'operational', 'Sign-in and session plumbing are available.'),
+    component(
+      'Automation',
+      'Agent Runtime',
+      runtimeReady ? 'operational' : 'degraded',
+      runtimeReady ? 'Runtime checks are passing.' : 'Runtime is reachable, but one or more host capabilities need attention.'
+    ),
+    component(
+      'Automation',
+      'AI Gateway',
+      hasAi ? 'operational' : 'degraded',
+      hasAi ? 'AI provider routing is configured.' : 'AI routing is available, but no public provider configuration is detected.'
+    ),
+    component(
+      'Devices',
+      'Browser & Desktop Control',
+      hasBrowser && hasDesktop ? 'operational' : 'degraded',
+      hasBrowser && hasDesktop ? 'Control gateways are ready.' : 'One control gateway is not currently initialized.'
+    ),
+    component(
+      'Communication',
+      'Messaging Bridges',
+      hasMessaging ? 'operational' : 'degraded',
+      hasMessaging ? 'Messaging bridge manager is online.' : 'Messaging bridge manager is not initialized.'
+    ),
+    component(
+      'Communication',
+      'Integrations & OAuth',
+      hasIntegrations && hasMcp ? 'operational' : 'degraded',
+      hasIntegrations && hasMcp ? 'Integration and MCP services are available.' : 'Some integration plumbing is not initialized.'
+    ),
+    component(
+      'Data',
+      'Storage & Memory',
+      storageReady && hasMemory ? 'operational' : 'unavailable',
+      storageReady && hasMemory ? 'Database and memory services are responding.' : 'Storage or memory services are not responding.'
+    ),
+  ];
+
+  const status = overallStatus(components);
+  return {
+    product: 'NeoAgent',
+    status,
+    updatedAt: new Date().toISOString(),
+    refreshAfterSeconds: 60,
+    note: status === 'operational'
+      ? 'All systems are behaving. Suspiciously mature of them.'
+      : 'A few systems want a moment. We are listening politely.',
+    components,
+  };
+}
+
+module.exports = {
+  buildPublicStatus,
+};

package/server/services/runtime/settings.js

@@ -101,6 +101,12 @@ function serializeRuntimeSettingValue(key, value) {
 }
 
 function redactRuntimeSettingValue(key, value) {
+  if (/^social_reach_cookies_/i.test(String(key || ''))) {
+    return {
+      configured: Boolean(value),
+      redacted: true,
+    };
+  }
   return value;
 }
 

package/server/services/social_reach/channels/base.js

@@ -0,0 +1,56 @@
+'use strict';
+
+class SocialReachChannel {
+  constructor(definition) {
+    this.id = definition.id;
+    this.label = definition.label;
+    this.tier = definition.tier;
+    this.setupKind = definition.setupKind;
+    this.hosts = definition.hosts || [];
+    this.domains = definition.domains || [];
+  }
+
+  canHandleUrl(url) {
+    if (!this.hosts.length) return false;
+    let parsed;
+    try {
+      parsed = new URL(String(url || ''));
+    } catch {
+      return false;
+    }
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+    return this.hosts.some((candidate) => {
+      const normalized = String(candidate).toLowerCase().replace(/^www\./, '');
+      return host === normalized || host.endsWith(`.${normalized}`);
+    });
+  }
+
+  async check() {
+    return {
+      platform: this.id,
+      label: this.label,
+      ready: true,
+      status: 'ok',
+      activeBackend: 'node',
+      tier: this.tier,
+      setupKind: this.setupKind,
+      message: 'Ready.',
+    };
+  }
+
+  async read() {
+    const error = new Error(`${this.label} reading is not implemented.`);
+    error.status = 501;
+    throw error;
+  }
+
+  async search() {
+    const error = new Error(`${this.label} search is not implemented.`);
+    error.status = 501;
+    throw error;
+  }
+}
+
+module.exports = {
+  SocialReachChannel,
+};

package/server/services/social_reach/channels/github.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+const { assertHttpUrl, fetchJson, normalizeLimit } = require('../utils');
+
+function parseRepoUrl(url) {
+  const parsed = assertHttpUrl(url);
+  const parts = parsed.pathname.split('/').filter(Boolean);
+  if (parsed.hostname.replace(/^www\./, '') !== 'github.com' || parts.length < 2) {
+    const error = new Error('A GitHub repository URL is required.');
+    error.status = 400;
+    throw error;
+  }
+  return { owner: parts[0], repo: parts[1].replace(/\.git$/, '') };
+}
+
+class GithubChannel extends SocialReachChannel {
+  constructor() {
+    super(getPlatformDefinition('github'));
+  }
+
+  async check() {
+    return {
+      ...(await super.check()),
+      activeBackend: 'github_rest_public',
+      message: 'Public GitHub repository read/search is available through the GitHub REST API.',
+    };
+  }
+
+  async read({ url }) {
+    const { owner, repo } = parseRepoUrl(url);
+    const data = await fetchJson(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`);
+    return {
+      platform: this.id,
+      owner,
+      repo,
+      title: data.full_name || `${owner}/${repo}`,
+      description: data.description || '',
+      url: data.html_url || `https://github.com/${owner}/${repo}`,
+      stars: data.stargazers_count || 0,
+      forks: data.forks_count || 0,
+      openIssues: data.open_issues_count || 0,
+      language: data.language || null,
+      defaultBranch: data.default_branch || null,
+      source: 'github_rest_public',
+    };
+  }
+
+  async search({ query, limit }) {
+    const q = String(query || '').trim();
+    if (!q) {
+      const error = new Error('query is required.');
+      error.status = 400;
+      throw error;
+    }
+    const data = await fetchJson(`https://api.github.com/search/repositories?q=${encodeURIComponent(q)}&per_page=${normalizeLimit(limit, 10, 30)}`);
+    return {
+      platform: this.id,
+      query: q,
+      results: (data.items || []).map((item) => ({
+        name: item.full_name,
+        description: item.description || '',
+        url: item.html_url,
+        stars: item.stargazers_count || 0,
+        language: item.language || null,
+      })),
+      source: 'github_rest_public',
+    };
+  }
+}
+
+module.exports = {
+  GithubChannel,
+};

package/server/services/social_reach/channels/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { GithubChannel } = require('./github');
+const { LinkedinChannel } = require('./linkedin');
+const { RssChannel } = require('./rss');
+const { UnsupportedChannel } = require('./unsupported');
+const { V2exChannel } = require('./v2ex');
+const { WebChannel } = require('./web');
+const { XueqiuChannel } = require('./xueqiu');
+const { YoutubeChannel } = require('./youtube');
+
+function createChannels() {
+  return [
+    new GithubChannel(),
+    new YoutubeChannel(),
+    new RssChannel(),
+    new V2exChannel(),
+    new XueqiuChannel(),
+    new LinkedinChannel(),
+    new UnsupportedChannel('twitter'),
+    new UnsupportedChannel('reddit'),
+    new UnsupportedChannel('facebook'),
+    new UnsupportedChannel('instagram'),
+    new UnsupportedChannel('bilibili'),
+    new UnsupportedChannel('xiaohongshu'),
+    new UnsupportedChannel('xiaoyuzhou'),
+    new UnsupportedChannel('exa_search'),
+    new WebChannel(),
+  ];
+}
+
+module.exports = {
+  createChannels,
+};

package/server/services/social_reach/channels/linkedin.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+const { assertHttpUrl, compactText, fetchText } = require('../utils');
+
+class LinkedinChannel extends SocialReachChannel {
+  constructor() {
+    super(getPlatformDefinition('linkedin'));
+  }
+
+  async check() {
+    return {
+      ...(await super.check()),
+      activeBackend: 'jina_reader_public',
+      message: 'Public LinkedIn pages can be read through Jina Reader. Logged-in profile/job automation is unavailable in Node-only mode.',
+    };
+  }
+
+  async read({ url }) {
+    const parsed = assertHttpUrl(url);
+    const text = await fetchText(`https://r.jina.ai/${parsed.toString()}`, { headers: { accept: 'text/plain' } });
+    return {
+      platform: this.id,
+      url: parsed.toString(),
+      content: compactText(text, 16000),
+      source: 'jina_reader_public',
+    };
+  }
+}
+
+module.exports = {
+  LinkedinChannel,
+};

package/server/services/social_reach/channels/rss.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const cheerio = require('cheerio');
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+const { assertHttpUrl, compactText, fetchText, normalizeLimit } = require('../utils');
+
+function firstText($, item, names) {
+  for (const name of names) {
+    const value = $(item).find(name).first().text().trim();
+    if (value) return value;
+  }
+  return '';
+}
+
+class RssChannel extends SocialReachChannel {
+  constructor() {
+    super(getPlatformDefinition('rss'));
+  }
+
+  canHandleUrl(url) {
+    const text = String(url || '').toLowerCase();
+    return /(?:\/feed\b|\/rss\b|\.xml\b|atom)/.test(text);
+  }
+
+  async check() {
+    return {
+      ...(await super.check()),
+      activeBackend: 'node_xml',
+      message: 'Reads RSS and Atom feeds with the built-in Node parser.',
+    };
+  }
+
+  async read({ url, limit }) {
+    const parsed = assertHttpUrl(url);
+    const xml = await fetchText(parsed.toString());
+    const $ = cheerio.load(xml, { xmlMode: true });
+    const entries = $('item, entry').toArray().slice(0, normalizeLimit(limit, 20, 100));
+    const title = $('channel > title, feed > title').first().text().trim() || null;
+    return {
+      platform: this.id,
+      url: parsed.toString(),
+      title,
+      items: entries.map((item) => ({
+        title: firstText($, item, ['title']),
+        url: firstText($, item, ['link']) || $(item).find('link').first().attr('href') || '',
+        summary: compactText(firstText($, item, ['description', 'summary', 'content']), 1200),
+        author: firstText($, item, ['author name', 'author', 'dc\\:creator']),
+        publishedAt: firstText($, item, ['pubDate', 'published', 'updated']),
+      })),
+      source: 'rss',
+    };
+  }
+}
+
+module.exports = {
+  RssChannel,
+};

package/server/services/social_reach/channels/unsupported.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+
+const MESSAGES = Object.freeze({
+  twitter: 'X/Twitter requires brittle authenticated browser/API access. It is listed for setup visibility but not implemented under the Node-only constraint.',
+  reddit: 'Reddit search/read currently needs authenticated browser or third-party tooling for reliable access. It is not implemented under the Node-only constraint.',
+  facebook: 'Facebook content access requires a logged-in browser session or approved Graph API app. It is not implemented under the Node-only constraint.',
+  instagram: 'Instagram content access requires a logged-in browser session or approved Graph API app. It is not implemented under the Node-only constraint.',
+  bilibili: 'Bilibili support in Agent-Reach depends on non-Node tooling. It is not implemented under the Node-only constraint.',
+  xiaohongshu: 'Xiaohongshu support depends on authenticated browser automation or non-Node tooling. It is not implemented under the Node-only constraint.',
+  xiaoyuzhou: 'Xiaoyuzhou transcription needs media download and Whisper-style transcription setup. It is not implemented under the Node-only constraint.',
+  exa_search: 'Exa MCP setup depends on external MCP tooling. Use NeoAgent web search or configure an MCP server separately.',
+});
+
+class UnsupportedChannel extends SocialReachChannel {
+  constructor(platform) {
+    super(getPlatformDefinition(platform));
+  }
+
+  async check() {
+    return {
+      platform: this.id,
+      label: this.label,
+      ready: false,
+      status: 'off',
+      activeBackend: null,
+      tier: this.tier,
+      setupKind: this.setupKind,
+      message: MESSAGES[this.id] || `${this.label} is unavailable in Node-only mode.`,
+    };
+  }
+
+  async read() {
+    const status = await this.check();
+    const error = new Error(status.message);
+    error.status = 501;
+    throw error;
+  }
+
+  async search() {
+    return this.read();
+  }
+}
+
+module.exports = {
+  UnsupportedChannel,
+};

package/server/services/social_reach/channels/v2ex.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+const { assertHttpUrl, fetchJson, normalizeLimit } = require('../utils');
+
+function shapeTopic(item = {}) {
+  const node = item.node || {};
+  const member = item.member || {};
+  return {
+    id: item.id || null,
+    title: item.title || '',
+    url: item.url || (item.id ? `https://www.v2ex.com/t/${item.id}` : ''),
+    content: item.content || '',
+    replies: item.replies || 0,
+    nodeName: node.name || '',
+    nodeTitle: node.title || '',
+    author: member.username || '',
+    createdAt: item.created || null,
+  };
+}
+
+class V2exChannel extends SocialReachChannel {
+  constructor() {
+    super(getPlatformDefinition('v2ex'));
+  }
+
+  async check() {
+    return {
+      ...(await super.check()),
+      activeBackend: 'v2ex_public_api',
+      message: 'Public API supports hot topics, node topics, topic details, and users.',
+    };
+  }
+
+  async read({ url, limit }) {
+    const parsed = assertHttpUrl(url);
+    const match = parsed.pathname.match(/^\/t\/(\d+)/);
+    if (!match) {
+      return this.search({ query: parsed.searchParams.get('q') || 'hot', limit });
+    }
+    const topicId = match[1];
+    const topicData = await fetchJson(`https://www.v2ex.com/api/topics/show.json?id=${encodeURIComponent(topicId)}`);
+    const topic = Array.isArray(topicData) ? topicData[0] || {} : topicData || {};
+    const replies = await fetchJson(`https://www.v2ex.com/api/replies/show.json?topic_id=${encodeURIComponent(topicId)}&page=1`)
+      .catch(() => []);
+    return {
+      platform: this.id,
+      ...shapeTopic(topic),
+      repliesList: (Array.isArray(replies) ? replies : [])
+        .slice(0, normalizeLimit(limit, 50, 100))
+        .map((reply) => ({
+          author: reply.member?.username || '',
+          content: reply.content || '',
+          createdAt: reply.created || null,
+        })),
+      source: 'v2ex_public_api',
+    };
+  }
+
+  async search({ query, limit }) {
+    const normalized = String(query || '').trim().toLowerCase();
+    const capped = normalizeLimit(limit, 20, 100);
+    if (normalized && normalized !== 'hot') {
+      const data = await fetchJson(`https://www.v2ex.com/api/topics/show.json?node_name=${encodeURIComponent(normalized)}&page=1`);
+      return {
+        platform: this.id,
+        query: normalized,
+        results: (Array.isArray(data) ? data : []).slice(0, capped).map(shapeTopic),
+        source: 'v2ex_public_api',
+      };
+    }
+    const data = await fetchJson('https://www.v2ex.com/api/topics/hot.json');
+    return {
+      platform: this.id,
+      query: 'hot',
+      results: (Array.isArray(data) ? data : []).slice(0, capped).map(shapeTopic),
+      source: 'v2ex_public_api',
+    };
+  }
+}
+
+module.exports = {
+  V2exChannel,
+};

package/server/services/social_reach/channels/web.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { SocialReachChannel } = require('./base');
+const { getPlatformDefinition } = require('../platforms');
+const { assertHttpUrl, compactText, fetchText } = require('../utils');
+
+class WebChannel extends SocialReachChannel {
+  constructor() {
+    super(getPlatformDefinition('web'));
+  }
+
+  canHandleUrl() {
+    return true;
+  }
+
+  async check() {
+    return {
+      ...(await super.check()),
+      activeBackend: 'jina_reader',
+      message: 'Reads public web pages through Jina Reader.',
+    };
+  }
+
+  async read({ url }) {
+    const parsed = assertHttpUrl(url);
+    const target = `https://r.jina.ai/${parsed.toString()}`;
+    const text = await fetchText(target, { headers: { accept: 'text/plain' } });
+    return {
+      platform: this.id,
+      url: parsed.toString(),
+      title: null,
+      content: compactText(text, 20000),
+      source: 'jina_reader',
+    };
+  }
+}
+
+module.exports = {
+  WebChannel,
+};