neoagent 1.4.0 → 1.4.3

package/server/services/browser/controller.js

@@ -1,36 +1,118 @@
 const path = require('path');
 const fs = require('fs');
+const { DATA_DIR } = require('../../../runtime/paths');
 
-const SCREENSHOTS_DIR = path.join(__dirname, '..', '..', '..', 'data', 'screenshots');
+const SCREENSHOTS_DIR = path.join(DATA_DIR, 'screenshots');
 if (!fs.existsSync(SCREENSHOTS_DIR)) fs.mkdirSync(SCREENSHOTS_DIR, { recursive: true });
 
+const USER_AGENTS = [
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+];
+
+const VIEWPORTS = [
+  { width: 1280, height: 800 },
+  { width: 1366, height: 768 },
+  { width: 1440, height: 900 },
+  { width: 1920, height: 1080 },
+];
+
+function rand(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
 class BrowserController {
   constructor(io) {
     this.io = io;
     this.browser = null;
     this.page = null;
     this.launching = false;
-    this.headless = true; // can be toggled via setHeadless()
+    this.headless = true;
+    this._viewport = VIEWPORTS[0];
+    this._userAgent = USER_AGENTS[0];
   }
 
   async setHeadless(val) {
     const wasHeadless = this.headless;
     this.headless = val !== false && val !== 'false';
-    // Close browser so it relaunches with new setting next time
     if (wasHeadless !== this.headless) {
       await this.close().catch(() => { });
     }
   }
 
-  // Alias used by graceful shutdown in server.js
   async closeBrowser() {
     return this.close();
   }
 
+  async _applyStealthToPage(page) {
+    const ua = this._userAgent;
+    const vp = this._viewport;
+
+    await page.setUserAgent(ua);
+    await page.setViewport(vp);
+    await page.setExtraHTTPHeaders({
+      'Accept-Language': 'en-US,en;q=0.9',
+    });
+
+    // Inject fingerprint overrides before any page script runs
+    await page.evaluateOnNewDocument(`
+      (() => {
+        // Remove webdriver flag
+        Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+
+        // Realistic language/platform
+        Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
+        Object.defineProperty(navigator, 'platform', { get: () => 'MacIntel' });
+        Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => ${rand(4, 16)} });
+        Object.defineProperty(navigator, 'deviceMemory', { get: () => ${[4, 8, 16][rand(0, 2)]} });
+
+        // Make it look like a real Chrome install
+        window.chrome = {
+          app: { isInstalled: false, InstallState: {}, RunningState: {} },
+          runtime: {},
+          loadTimes: function() {},
+          csi: function() {},
+        };
+
+        // Permissions API — bots often show "denied" for notifications
+        const origQuery = window.navigator.permissions?.query?.bind(navigator.permissions);
+        if (origQuery) {
+          navigator.permissions.query = (parameters) =>
+            parameters.name === 'notifications'
+              ? Promise.resolve({ state: Notification.permission })
+              : origQuery(parameters);
+        }
+
+        // Hide automation plugins gap
+        Object.defineProperty(navigator, 'plugins', {
+          get: () => {
+            const arr = [
+              { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+              { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+              { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+            ];
+            arr.item = i => arr[i];
+            arr.namedItem = n => arr.find(p => p.name === n) || null;
+            arr.refresh = () => {};
+            Object.defineProperty(arr, 'length', { get: () => arr.length });
+            return arr;
+          }
+        });
+      })();
+    `);
+  }
+
   async ensureBrowser() {
     if (this.browser && this.browser.isConnected()) return;
     if (this.launching) {
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      await sleep(2000);
       return;
     }
 
@@ -40,29 +122,28 @@ class BrowserController {
       const StealthPlugin = require('puppeteer-extra-plugin-stealth');
       puppeteer.use(StealthPlugin());
 
+      this._userAgent = USER_AGENTS[rand(0, USER_AGENTS.length - 1)];
+      this._viewport = VIEWPORTS[rand(0, VIEWPORTS.length - 1)];
+
       this.browser = await puppeteer.launch({
         headless: this.headless ? 'new' : false,
         args: [
           '--no-sandbox',
           '--disable-setuid-sandbox',
           '--disable-dev-shm-usage',
-          '--disable-gpu',
-          '--window-size=1280,800'
+          '--disable-blink-features=AutomationControlled',
+          '--disable-infobars',
+          '--no-first-run',
+          '--no-default-browser-check',
+          '--lang=en-US,en',
+          `--window-size=${this._viewport.width},${this._viewport.height}`,
         ],
-        defaultViewport: { width: 1280, height: 800 }
+        defaultViewport: this._viewport,
+        ignoreDefaultArgs: ['--enable-automation'],
       });
-      this.page = await this.browser.newPage();
 
-      const userAgents = [
-        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0',
-        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15'
-      ];
-      const randomUA = userAgents[Math.floor(Math.random() * userAgents.length)];
-      await this.page.setUserAgent(randomUA);
-      this._currentUserAgent = randomUA;
+      this.page = await this.browser.newPage();
+      await this._applyStealthToPage(this.page);
     } finally {
       this.launching = false;
     }
@@ -72,9 +153,7 @@ class BrowserController {
     await this.ensureBrowser();
     if (!this.page || this.page.isClosed()) {
       this.page = await this.browser.newPage();
-      if (this._currentUserAgent) {
-        await this.page.setUserAgent(this._currentUserAgent);
-      }
+      await this._applyStealthToPage(this.page);
     }
     return this.page;
   }
@@ -113,6 +192,9 @@ class BrowserController {
         await page.waitForSelector(options.waitFor, { timeout: 10000 }).catch(() => { });
       }
 
+      // Simulate human reading delay
+      await sleep(rand(500, 1500));
+
       const title = await page.title();
       const currentUrl = page.url();
 
@@ -125,8 +207,7 @@ class BrowserController {
         const body = document.body;
         if (!body) return '';
         const clone = body.cloneNode(true);
-        const scripts = clone.querySelectorAll('script, style, noscript');
-        scripts.forEach(s => s.remove());
+        clone.querySelectorAll('script, style, noscript').forEach(s => s.remove());
         return clone.innerText.slice(0, 10000);
       });
 
@@ -152,40 +233,39 @@ class BrowserController {
     const page = await this.ensurePage();
 
     try {
+      let target = null;
+
       if (text && !selector) {
         const elements = await page.$$('a, button, [role="button"], input[type="submit"], [onclick]');
-        let found = false;
         for (const el of elements) {
           const elText = await page.evaluate(e => e.innerText || e.value || e.getAttribute('aria-label') || '', el);
           if (elText.toLowerCase().includes(text.toLowerCase())) {
-            await el.click();
-            found = true;
+            target = el;
             break;
           }
         }
-        if (!found) {
-          return { error: `No clickable element found with text: ${text}` };
-        }
+        if (!target) return { error: `No clickable element found with text: ${text}` };
       } else if (selector) {
-        await page.click(selector);
+        target = await page.$(selector);
+        if (!target) return { error: `Element not found: ${selector}` };
       } else {
         return { error: 'Either selector or text required' };
       }
 
-      await new Promise(r => setTimeout(r, 1000));
+      // Human-like: hover first, then click with a hold delay
+      await target.hover();
+      await sleep(rand(80, 250));
+      await target.click({ delay: rand(50, 150) });
 
-      let screenshotResult = null;
-      if (screenshot) {
-        screenshotResult = await this.takeScreenshot();
-      }
+      await sleep(rand(800, 1800));
 
-      const currentUrl = page.url();
-      const title = await page.title();
+      let screenshotResult = null;
+      if (screenshot) screenshotResult = await this.takeScreenshot();
 
       return {
         success: true,
-        url: currentUrl,
-        title,
+        url: page.url(),
+        title: await page.title(),
         screenshotPath: screenshotResult?.screenshotPath || null
       };
     } catch (err) {
@@ -202,21 +282,17 @@ class BrowserController {
         await page.keyboard.press('Backspace');
       }
 
-      // Simulate human typing speeds (between 30ms and 150ms per keystroke)
       for (const char of text) {
-        const charDelay = Math.floor(Math.random() * (150 - 30 + 1) + 30);
-        await page.type(selector, char, { delay: charDelay });
+        await page.type(selector, char, { delay: rand(30, 150) });
       }
 
       if (options.pressEnter) {
         await page.keyboard.press('Enter');
-        await new Promise(r => setTimeout(r, 1000));
+        await sleep(1000);
       }
 
       let screenshotResult = null;
-      if (options.screenshot !== false) {
-        screenshotResult = await this.takeScreenshot();
-      }
+      if (options.screenshot !== false) screenshotResult = await this.takeScreenshot();
 
       return {
         success: true,
@@ -268,7 +344,7 @@ class BrowserController {
   }
 
   async screenshot(options = {}) {
-    return await this.takeScreenshot(options);
+    return this.takeScreenshot(options);
   }
 
   async launch(options = {}) {

package/server/services/manager.js

@@ -5,7 +5,9 @@ const { MemoryManager } = require('./memory/manager');
 const { MCPClient } = require('./mcp/client');
 const { BrowserController } = require('./browser/controller');
 const { AgentEngine } = require('./ai/engine');
+const { LearningManager } = require('./ai/learning');
 const { MultiStepOrchestrator } = require('./ai/multiStep');
+const { SkillRunner } = require('./ai/toolRunner');
 const { MessagingManager } = require('./messaging/manager');
 const { Scheduler } = require('./scheduler/cron');
 const { setupWebSocket } = require('./websocket');
@@ -29,7 +31,21 @@ async function startServices(app, io) {
         }
         app.locals.browserController = browserController;
 
-        const agentEngine = new AgentEngine(io, { memoryManager, mcpClient, browserController, messagingManager: null });
+        const skillRunner = new SkillRunner();
+        await skillRunner.loadSkills();
+        app.locals.skillRunner = skillRunner;
+
+        const learningManager = new LearningManager(skillRunner, io);
+        app.locals.learningManager = learningManager;
+
+        const agentEngine = new AgentEngine(io, {
+            memoryManager,
+            mcpClient,
+            browserController,
+            messagingManager: null,
+            skillRunner,
+            learningManager
+        });
         app.locals.agentEngine = agentEngine;
 
         const multiStep = new MultiStepOrchestrator(agentEngine, io);
@@ -162,12 +178,19 @@ async function startServices(app, io) {
             await processMessage(userId, msg);
         });
 
-        const scheduler = new Scheduler(io, agentEngine);
+        const scheduler = new Scheduler(io, agentEngine, app);
         app.locals.scheduler = scheduler;
         agentEngine.scheduler = scheduler;
         scheduler.start();
 
-        setupWebSocket(io, { agentEngine, messagingManager, mcpClient, scheduler, memoryManager, app });
+        setupWebSocket(io, {
+            agentEngine,
+            messagingManager,
+            mcpClient,
+            scheduler,
+            memoryManager,
+            app
+        });
         app.locals.io = io;
 
         console.log('All services initialized');

package/server/services/mcp/client.js

@@ -12,7 +12,7 @@ class DBAuthProvider {
   }
 
   get redirectUrl() {
-    const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 8000}`;
+    const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 3333}`;
     return `${baseUrl}/api/mcp/oauth/callback`;
   }
 

package/server/services/memory/embeddings.js

@@ -2,30 +2,80 @@
 
 /**
  * Embedding helpers for the semantic memory system.
- * Uses OpenAI text-embedding-3-small (1536 dims) when available.
- * Gracefully degrades to keyword search if OPENAI_API_KEY is missing.
+ *
+ * Provider selection (in priority order):
+ *   1. Google (text-embedding-004, 768 dims) — when provider hint is 'google' and GOOGLE_AI_KEY is set
+ *   2. OpenAI (text-embedding-3-small, 1536 dims) — when OPENAI_API_KEY is set
+ *   3. Keyword fallback — when no API key is available
  */
 
 const https = require('https');
 
-const EMBEDDING_MODEL = 'text-embedding-3-small';
-const EMBED_DIM = 1536;
+const OPENAI_MODEL = 'text-embedding-3-small';
+const OPENAI_DIM = 1536;
+const GOOGLE_MODEL = 'text-embedding-004';
+const GOOGLE_DIM = 768;
 
-/**
- * Get an embedding vector for a piece of text.
- * Returns a Float32Array of length EMBED_DIM, or null if unavailable.
- */
-async function getEmbedding(text) {
+// Exported so callers can sanity-check stored vector dimensions if needed
+const EMBED_DIM = OPENAI_DIM;
+const EMBED_DIM_GOOGLE = GOOGLE_DIM;
+
+async function getGeminiEmbedding(text) {
+  const apiKey = process.env.GOOGLE_AI_KEY;
+  if (!apiKey) return null;
+  if (!text || !text.trim()) return null;
+
+  const truncated = text.slice(0, 25000);
+
+  return new Promise((resolve) => {
+    const body = JSON.stringify({
+      model: `models/${GOOGLE_MODEL}`,
+      content: { parts: [{ text: truncated }] }
+    });
+
+    const path = `/v1beta/models/${GOOGLE_MODEL}:embedContent?key=${apiKey}`;
+    const options = {
+      hostname: 'generativelanguage.googleapis.com',
+      path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          const vec = parsed.embedding?.values;
+          if (!vec) return resolve(null);
+          resolve(new Float32Array(vec));
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.setTimeout(15000, () => { req.destroy(); resolve(null); });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function getOpenAIEmbedding(text) {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) return null;
   if (!text || !text.trim()) return null;
 
-  // Truncate very long text to stay within token limits (~8k tokens)
   const truncated = text.slice(0, 25000);
 
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve) => {
     const body = JSON.stringify({
-      model: EMBEDDING_MODEL,
+      model: OPENAI_MODEL,
       input: truncated,
       encoding_format: 'float'
     });
@@ -64,6 +114,21 @@ async function getEmbedding(text) {
   });
 }
 
+/**
+ * Get an embedding vector for a piece of text.
+ * @param {string} text
+ * @param {string} [provider] - 'google' to prefer Gemini embeddings
+ * @returns {Float32Array|null}
+ */
+async function getEmbedding(text, provider) {
+  if (!text || !text.trim()) return null;
+  if (provider === 'google' && process.env.GOOGLE_AI_KEY) {
+    const vec = await getGeminiEmbedding(text);
+    if (vec) return vec;
+  }
+  return getOpenAIEmbedding(text);
+}
+
 /**
  * Cosine similarity between two Float32Arrays.
  * Returns a value in [-1, 1]; higher = more similar.
@@ -72,7 +137,7 @@ function cosineSimilarity(a, b) {
   if (!a || !b || a.length !== b.length) return 0;
   let dot = 0, magA = 0, magB = 0;
   for (let i = 0; i < a.length; i++) {
-    dot  += a[i] * b[i];
+    dot += a[i] * b[i];
     magA += a[i] * a[i];
     magB += b[i] * b[i];
   }
@@ -122,5 +187,6 @@ module.exports = {
   serializeEmbedding,
   deserializeEmbedding,
   keywordSimilarity,
-  EMBED_DIM
+  EMBED_DIM,
+  EMBED_DIM_GOOGLE
 };