neoagent 2.3.1-beta.2 → 2.3.1-beta.21

package/server/routes/integrations.js

@@ -361,4 +361,90 @@ router.get('/:provider/tools/status', (req, res) => {
   }
 });
 
+router.get('/:provider/config', (req, res) => {
+  try {
+    const manager = getIntegrationManager(req);
+    if (!manager) {
+      throw new Error('Official integration manager is not available on app.locals.integrationManager.');
+    }
+    const provider = manager.getProvider(req.params.provider);
+    if (!provider) {
+      throw new Error(`Unknown integration provider: ${req.params.provider}`);
+    }
+    if (typeof provider.getUserConfig !== 'function') {
+      return res.status(404).json({
+        error: `${provider.label} does not support per-user configuration.`,
+      });
+    }
+    const config = provider.getUserConfig({
+      userId: req.session.userId,
+      agentId: resolveAgentId(req.session.userId, getAgentIdFromRequest(req)),
+    });
+    res.json({
+      provider: provider.key,
+      config,
+    });
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.put('/:provider/config', async (req, res) => {
+  try {
+    const manager = getIntegrationManager(req);
+    if (!manager) {
+      throw new Error('Official integration manager is not available on app.locals.integrationManager.');
+    }
+    const provider = manager.getProvider(req.params.provider);
+    if (!provider) {
+      throw new Error(`Unknown integration provider: ${req.params.provider}`);
+    }
+    if (typeof provider.saveUserConfig !== 'function') {
+      return res.status(404).json({
+        error: `${provider.label} does not support per-user configuration.`,
+      });
+    }
+    const config = await provider.saveUserConfig({
+      userId: req.session.userId,
+      agentId: resolveAgentId(req.session.userId, getAgentIdFromRequest(req)),
+      config: req.body?.config || req.body || {},
+    });
+    res.json({
+      provider: provider.key,
+      config,
+      saved: true,
+    });
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.delete('/:provider/config', async (req, res) => {
+  try {
+    const manager = getIntegrationManager(req);
+    if (!manager) {
+      throw new Error('Official integration manager is not available on app.locals.integrationManager.');
+    }
+    const provider = manager.getProvider(req.params.provider);
+    if (!provider) {
+      throw new Error(`Unknown integration provider: ${req.params.provider}`);
+    }
+    if (typeof provider.clearUserConfig !== 'function') {
+      return res.status(404).json({
+        error: `${provider.label} does not support per-user configuration.`,
+      });
+    }
+    await provider.clearUserConfig({
+      userId: req.session.userId,
+      agentId: resolveAgentId(req.session.userId, getAgentIdFromRequest(req)),
+    });
+    res.json({
+      provider: provider.key,
+      cleared: true,
+    });
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
 module.exports = router;

package/server/routes/memory.js

@@ -1,11 +1,20 @@
 const express = require('express');
 const router = express.Router();
+const rateLimit = require('express-rate-limit');
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
 
 router.use(requireAuth);
 
+const apiKeyMutationLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 60,
+  message: { error: 'Too many API key update attempts, try again later' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
 function normalizeMemoryIds(value) {
   return [...new Set(
     (Array.isArray(value) ? value : [])
@@ -232,12 +241,12 @@ router.get('/api-keys', (req, res) => {
   res.json(masked);
 });
 
-router.put('/api-keys/:service', (req, res) => {
+router.put('/api-keys/:service', apiKeyMutationLimiter, (req, res) => {
   req.app.locals.memoryManager.setApiKey(req.params.service, req.body.key, req.session.userId);
   res.json({ success: true });
 });
 
-router.delete('/api-keys/:service', (req, res) => {
+router.delete('/api-keys/:service', apiKeyMutationLimiter, (req, res) => {
   req.app.locals.memoryManager.deleteApiKey(req.params.service, req.session.userId);
   res.json({ success: true });
 });

package/server/routes/screenHistory.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const express = require('express');
+const db = require('../db/database');
+const { getErrorMessage } = require('../services/bootstrap_helpers');
+
+const router = express.Router();
+
+router.get('/search', (req, res) => {
+  const { q, limit = 50, offset = 0 } = req.query;
+
+  if (!req.user || !req.user.id) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  try {
+    let results = [];
+    if (q) {
+      // Full text search
+      results = db.prepare(`
+        SELECT s.id, s.timestamp, s.app_name, s.text_content
+        FROM screen_history_fts fts
+        JOIN screen_history s ON fts.rowid = s.id
+        WHERE screen_history_fts MATCH ? AND s.user_id = ?
+        ORDER BY s.timestamp DESC
+        LIMIT ? OFFSET ?
+      `).all(q, req.user.id, Number(limit), Number(offset));
+    } else {
+      // Recent history
+      results = db.prepare(`
+        SELECT id, timestamp, app_name, text_content
+        FROM screen_history
+        WHERE user_id = ?
+        ORDER BY timestamp DESC
+        LIMIT ? OFFSET ?
+      `).all(req.user.id, Number(limit), Number(offset));
+    }
+
+    res.json({ results });
+  } catch (err) {
+    console.error('[ScreenHistory] Search error:', getErrorMessage(err));
+    res.status(500).json({ error: 'Failed to search screen history' });
+  }
+});
+
+module.exports = router;

package/server/routes/triggers.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const express = require('express');
+const db = require('../db/database');
+const { getErrorMessage } = require('../services/bootstrap_helpers');
+const { requireAuth } = require('../middleware/auth');
+
+const router = express.Router();
+
+router.use(requireAuth);
+
+router.post('/geofence', async (req, res) => {
+  const { label, latitude, longitude, radius_meters, action } = req.body;
+
+  try {
+    const userRow = db.prepare('SELECT id FROM users WHERE id = ?').get(req.user.id);
+    if (!userRow) return res.status(401).json({ error: 'Unauthorized' });
+
+    console.log(`[Triggers] Geofence entered: ${label} by user ${req.user.id}`);
+
+    // If an agentEngine is running, we can inject a prompt to process this context
+    const agentEngine = req.app.locals.agentEngine;
+    if (agentEngine) {
+      // Find active agent or use default
+      const defaultAgentId = db.prepare('SELECT id FROM agents WHERE user_id = ? ORDER BY is_default DESC LIMIT 1').get(req.user.id)?.id;
+      
+      if (defaultAgentId) {
+        // Fire and forget a trigger message to the agent
+        agentEngine.handleBackgroundTrigger(req.user.id, defaultAgentId, {
+          source: 'geofence',
+          label,
+          action: action || 'User entered a geofenced area. Check if there are any active reminders or tasks related to this location.'
+        }).catch(err => console.error('[Triggers] Agent evaluation failed:', err));
+      }
+    }
+
+    res.json({ success: true, message: 'Geofence trigger processed' });
+  } catch (err) {
+    console.error('[Triggers] Geofence error:', getErrorMessage(err));
+    res.status(500).json({ error: 'Failed to process geofence trigger' });
+  }
+});
+
+router.post('/notification', async (req, res) => {
+  const { app_package, title, body, action_taken } = req.body;
+
+  try {
+    const userRow = db.prepare('SELECT id FROM users WHERE id = ?').get(req.user.id);
+    if (!userRow) return res.status(401).json({ error: 'Unauthorized' });
+
+    console.log(`[Triggers] Notification received: ${app_package} - ${title}`);
+
+    db.prepare(`
+      INSERT INTO notification_history (user_id, app_package, title, body, action_taken)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(req.user.id, app_package || 'unknown', title || '', body || '', action_taken || 'none');
+
+    // Notify agent engine to proactively evaluate the notification
+    const agentEngine = req.app.locals.agentEngine;
+    if (agentEngine) {
+      const defaultAgentId = db.prepare('SELECT id FROM agents WHERE user_id = ? ORDER BY is_default DESC LIMIT 1').get(req.user.id)?.id;
+      
+      if (defaultAgentId) {
+        agentEngine.handleBackgroundTrigger(req.user.id, defaultAgentId, {
+          source: 'notification',
+          app_package,
+          title,
+          body,
+          instruction: 'Evaluate this notification. If it is an important reminder, calendar event, or urgent message, inform the user or take appropriate action.'
+        }).catch(err => console.error('[Triggers] Agent evaluation failed:', err));
+      }
+    }
+
+    res.json({ success: true, message: 'Notification trigger processed and stored' });
+  } catch (err) {
+    console.error('[Triggers] Notification error:', getErrorMessage(err));
+    res.status(500).json({ error: 'Failed to process notification trigger' });
+  }
+});
+
+module.exports = router;

package/server/services/ai/models.js

@@ -3,6 +3,8 @@ const { GoogleProvider } = require('./providers/google');
 const { GrokProvider } = require('./providers/grok');
 const { OllamaProvider } = require('./providers/ollama');
 const { OpenAIProvider } = require('./providers/openai');
+const { GithubCopilotProvider } = require('./providers/githubCopilot');
+const { OpenAICodexProvider } = require('./providers/openaiCodex');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -16,6 +18,30 @@ const STATIC_MODELS = [
         provider: 'grok',
         purpose: 'general'
     },
+    {
+        id: 'gpt-5.3',
+        label: 'GPT-5.3 (Copilot Default)',
+        provider: 'github-copilot',
+        purpose: 'general'
+    },
+    {
+        id: 'gpt-4.1',
+        label: 'GPT-4.1 (Copilot Fast)',
+        provider: 'github-copilot',
+        purpose: 'coding'
+    },
+    {
+        id: 'gpt-5.3-codex',
+        label: 'GPT-5.3 (Codex Default)',
+        provider: 'openai-codex',
+        purpose: 'general'
+    },
+    {
+        id: 'gpt-4.1-codex',
+        label: 'GPT-4.1 (Codex Fast)',
+        provider: 'openai-codex',
+        purpose: 'coding'
+    },
     {
         id: 'gpt-5-nano',
         label: 'GPT-5 Nano (Fast / Subagents)',
@@ -302,6 +328,10 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
     } else if (providerStr === 'ollama') {
         return new OllamaProvider({ baseUrl: runtime.baseUrl, ...providerOverrides });
+    } else if (providerStr === 'github-copilot') {
+        return new GithubCopilotProvider({ apiKey: runtime.apiKey, ...providerOverrides });
+    } else if (providerStr === 'openai-codex') {
+        return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }

package/server/services/ai/providers/githubCopilot.js

@@ -0,0 +1,97 @@
+const { OpenAIProvider } = require('./openai');
+
+class GithubCopilotProvider extends OpenAIProvider {
+  constructor(config = {}) {
+    // GitHub Copilot base URL defaults to the individual endpoint
+    const defaultBaseUrl = 'https://api.individual.githubcopilot.com';
+    const baseUrl = config.baseUrl || process.env.GITHUB_COPILOT_BASE_URL || defaultBaseUrl;
+
+    super({
+      ...config,
+      apiKey: config.apiKey || process.env.GITHUB_COPILOT_ACCESS_TOKEN,
+      baseUrl,
+      // Pass special headers required by GitHub Copilot
+      defaultHeaders: {
+        'Editor-Version': 'vscode/1.90.0',
+        'Editor-Plugin-Version': 'copilot-chat/0.15.0',
+        'User-Agent': 'GithubCopilot/1.155.0',
+        'X-Github-Api-Version': '2023-07-07',
+        'Copilot-Integration-Id': 'vscode-chat'
+      }
+    });
+    this.name = 'github-copilot';
+    this.githubToken = config.apiKey || process.env.GITHUB_COPILOT_ACCESS_TOKEN;
+    this.copilotToken = null;
+    this.tokenExpiresAt = 0;
+    this._refreshPromise = null;
+  }
+
+  async _refreshCopilotToken() {
+    if (this._refreshPromise) return this._refreshPromise;
+
+    const now = Math.floor(Date.now() / 1000);
+    // Refresh token if missing or expiring in less than 5 minutes
+    if (this.copilotToken && this.tokenExpiresAt >= now + 300) {
+      return;
+    }
+
+    this._refreshPromise = (async () => {
+      try {
+        if (!this.githubToken) {
+          throw new Error('GitHub Copilot access token is missing. Please run `neoagent login github-copilot`.');
+        }
+
+        const res = await fetch('https://api.github.com/copilot_internal/v2/token', {
+          headers: {
+            'Authorization': `token ${this.githubToken}`,
+            'Accept': 'application/json',
+            'User-Agent': 'NeoAgent/1.0.0'
+          }
+        });
+
+        if (!res.ok) {
+          const errorText = await res.text().catch(() => 'Unknown error');
+          throw new Error(`Failed to refresh GitHub Copilot token: HTTP ${res.status} - ${errorText}`);
+        }
+
+        const data = await res.json();
+        if (!data || typeof data.token !== 'string' || !data.token) {
+          throw new Error('Invalid token response from GitHub Copilot.');
+        }
+
+        this.copilotToken = data.token;
+        this.tokenExpiresAt = typeof data.expires_at === 'number'
+          ? data.expires_at
+          : Math.floor(new Date(data.expires_at).getTime() / 1000);
+
+        if (isNaN(this.tokenExpiresAt)) {
+          this.tokenExpiresAt = Math.floor(Date.now() / 1000) + 1800;
+        }
+
+        // Update the client's API key
+        this.client.apiKey = this.copilotToken;
+      } finally {
+        this._refreshPromise = null;
+      }
+    })();
+
+    return this._refreshPromise;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    await this._refreshCopilotToken();
+    return super.chat(messages, tools, options);
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    await this._refreshCopilotToken();
+    yield* super.stream(messages, tools, options);
+  }
+
+  async analyzeImage(options = {}) {
+    await this._refreshCopilotToken();
+    return super.analyzeImage(options);
+  }
+}
+
+module.exports = { GithubCopilotProvider };

package/server/services/ai/providers/openai.js

@@ -29,7 +29,8 @@ class OpenAIProvider extends BaseProvider {
     };
     this.client = new OpenAI({
       apiKey: config.apiKey || process.env.OPENAI_API_KEY,
-      baseURL: config.baseUrl || process.env.OPENAI_BASE_URL || undefined
+      baseURL: config.baseUrl || process.env.OPENAI_BASE_URL || undefined,
+      defaultHeaders: config.defaultHeaders || undefined
     });
   }
 

package/server/services/ai/providers/openaiCodex.js

@@ -0,0 +1,31 @@
+const { OpenAIProvider } = require('./openai');
+
+class OpenAICodexProvider extends OpenAIProvider {
+  constructor(config = {}) {
+    const officialBaseUrl = 'https://api.openai.com/v1';
+    const baseUrl = config.baseUrl || process.env.OPENAI_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
+    
+    if (!baseUrl.includes('api.openai.com') && !baseUrl.includes('chatgpt.com')) {
+      console.warn(`[OpenAICodex] Using non-official base URL: ${baseUrl}`);
+    } else if (baseUrl.includes('chatgpt.com')) {
+      console.info(`[OpenAICodex] Using ChatGPT subscription endpoint: ${baseUrl}`);
+    }
+
+    super({
+      ...config,
+      apiKey: config.apiKey || process.env.OPENAI_CODEX_ACCESS_TOKEN,
+      baseUrl,
+      defaultHeaders: {
+        'Editor-Version': process.env.OPENAI_CODEX_EDITOR_VERSION || 'vscode/1.99.0',
+        'Editor-Plugin-Version': process.env.OPENAI_CODEX_EDITOR_PLUGIN_VERSION || 'neoagent/1.0.0',
+        'User-Agent': process.env.OPENAI_CODEX_USER_AGENT || 'NeoAgent/1.0.0'
+      }
+    });
+    this.name = 'openai-codex';
+  }
+
+  // OpenAI Codex (subscription-based) uses the OAuth token directly as the API key.
+  // The base URL routes it through the ChatGPT backend-api.
+}
+
+module.exports = { OpenAICodexProvider };

package/server/services/ai/settings.js

@@ -59,6 +59,26 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
     defaultEnabled: false,
     defaultBaseUrl: 'https://api.minimax.io/anthropic'
   },
+  'github-copilot': {
+    id: 'github-copilot',
+    label: 'GitHub Copilot',
+    description: 'Use your GitHub Copilot subscription as an AI provider.',
+    envKey: 'GITHUB_COPILOT_ACCESS_TOKEN',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: false,
+    defaultBaseUrl: 'https://api.githubcopilot.com'
+  },
+  'openai-codex': {
+    id: 'openai-codex',
+    label: 'OpenAI Codex',
+    description: 'Use your ChatGPT/Codex subscription as an AI provider.',
+    envKey: 'OPENAI_CODEX_ACCESS_TOKEN',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: false,
+    defaultBaseUrl: 'https://api.openai.com/v1'
+  },
   ollama: {
     id: 'ollama',
     label: 'Ollama',

package/server/services/ai/systemPrompt.js

@@ -138,7 +138,7 @@ When drafting on behalf of the user, match their likely voice from available con
 If the user approves a previously shown draft, send that draft rather than silently rewriting it.
 
 TASKS
-Use one-time schedule triggers for single reminders or delayed actions, recurring schedule triggers for repeating automation, and official integration triggers when the task should react to connected Gmail, Outlook, Slack, Teams, or WhatsApp Personal events. When calling task tools, prefer one unified trigger section: trigger={ type, config }. Make task prompts self-contained: who/what to check, exact action to take, when to notify, and which channel to use if known.
+Use manual triggers for run-on-demand tasks, one-time schedule triggers for single reminders or delayed actions, recurring schedule triggers for repeating automation, and official integration triggers when the task should react to connected Gmail, Outlook, Slack, Teams, or WhatsApp Personal events. When calling task tools, prefer one unified trigger section: trigger={ type, config }. Make task prompts self-contained: who/what to check, exact action to take, when to notify, and which channel to use if known.
 Do not create vague tasks like "check this" when the future run would not know what "this" means. Resolve references into names, links, file paths, IDs, dates, and success criteria before saving the task.
 For notification tasks, distinguish between notifying the user in their current messaging channel, emailing the user, and contacting someone else. Default reminders should notify the user through the active messaging channel unless the user explicitly asks for email, phone, or a third party.
 When creating or updating a task, include whether it should notify every time, only on change, only on errors, or only when a condition is met. If unspecified, choose the least noisy useful behavior and say what you chose.

package/server/services/ai/tools.js

@@ -973,8 +973,8 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     name: { type: 'string', description: 'Short descriptive name for the task.' },
-                    trigger: { type: 'object', description: 'Unified trigger object. Prefer { type: "schedule" | integration_trigger_type, config: {...} }.' },
-                    trigger_type: { type: 'string', description: 'Trigger type such as schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, weather_event, or whatsapp_personal_message_received.' },
+                    trigger: { type: 'object', description: 'Unified trigger object. Prefer { type: "manual" | "schedule" | integration_trigger_type, config: {...} }.' },
+                    trigger_type: { type: 'string', description: 'Trigger type such as manual, schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, weather_event, or whatsapp_personal_message_received.' },
                     trigger_config: { type: 'object', description: 'Trigger-specific configuration object. For schedule triggers prefer { mode: "recurring", cronExpression: "m h dom mon dow" } or { mode: "one_time", runAt: ISO datetime }. 5-field cron only (seconds unsupported).' },
                     prompt: { type: 'string', description: 'The instructions the agent will run when the trigger fires.' },
                     enabled: { type: 'boolean', description: 'Whether to activate immediately.' },
@@ -1010,7 +1010,7 @@ function getAvailableTools(app, options = {}) {
                     task_id: { type: 'number', description: 'The numeric ID of the task to update.' },
                     name: { type: 'string', description: 'New name for the task.' },
                     trigger: { type: 'object', description: 'Unified trigger object. Use { type, config } to update trigger in one section.' },
-                    trigger_type: { type: 'string', description: 'Updated trigger type.' },
+                    trigger_type: { type: 'string', description: 'Updated trigger type, e.g. manual, schedule, or integration trigger type.' },
                     trigger_config: { type: 'object', description: 'Updated trigger-specific configuration. For schedule triggers use mode+cronExpression (recurring) or mode+runAt (one_time).' },
                     prompt: { type: 'string', description: 'Updated task prompt.' },
                     enabled: { type: 'boolean', description: 'Enable or disable the task.' },
@@ -1152,6 +1152,17 @@ function getAvailableTools(app, options = {}) {
                 required: ['image_path']
             }
         },
+        {
+            name: 'ocr_extract',
+            description: 'Extract raw text from an image locally using Tesseract OCR. This is faster and completely offline compared to analyze_image.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    image_path: { type: 'string', description: 'Absolute path to the image file' }
+                },
+                required: ['image_path']
+            }
+        },
         {
             name: 'read_health_data',
             description: 'Read the user\'s synced mobile health data. Omit metric_type for a summary of all available metrics. With metric_type, returns an aggregate summary (total, avg, min, max over all stored data) plus the most recent individual records. Always report the summary figures — avoid listing every raw record.',
@@ -2311,13 +2322,17 @@ async function executeTool(toolName, args, context, engine) {
                 if (!resolvedTrigger.hasType || !resolvedTrigger.triggerType) {
                     return { error: 'Task trigger type is required (use trigger.type or trigger_type).' };
                 }
-                if (!resolvedTrigger.hasConfig || resolvedTrigger.triggerConfig === undefined) {
+                const normalizedTriggerType = String(resolvedTrigger.triggerType || '').trim();
+                const triggerConfig = (!resolvedTrigger.hasConfig || resolvedTrigger.triggerConfig === undefined)
+                    ? (normalizedTriggerType === 'manual' ? {} : undefined)
+                    : resolvedTrigger.triggerConfig;
+                if (triggerConfig === undefined) {
                     return { error: 'Task trigger config is required (use trigger.config or trigger_config).' };
                 }
                 const task = await s.createTask(userId, {
                     name: args.name,
-                    triggerType: resolvedTrigger.triggerType,
-                    triggerConfig: resolvedTrigger.triggerConfig,
+                    triggerType: normalizedTriggerType,
+                    triggerConfig,
                     prompt: args.prompt,
                     enabled: args.enabled !== false,
                     model: args.model || null,
@@ -2580,6 +2595,20 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'ocr_extract': {
+            try {
+                const fs = require('fs');
+                if (!fs.existsSync(args.image_path)) {
+                    return { error: 'File not found: ' + args.image_path };
+                }
+                const Tesseract = require('tesseract.js');
+                const result = await Tesseract.recognize(args.image_path, 'eng');
+                return { text: result.data.text, confidence: result.data.confidence };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
         case 'spawn_subagent': {
             try {
                 const task = args.context ? `${args.task}\n\nContext: ${args.context}` : args.task;

package/server/services/browser/controller.js

@@ -6,11 +6,11 @@ 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/135.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.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',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36',
 ];
 
 const VIEWPORTS = [
@@ -148,6 +148,50 @@ class BrowserController {
             return arr;
           }
         });
+
+        // WebGL Spoofing
+        const getParameterProxyHandler = {
+          apply: function(target, ctx, args) {
+            const param = args[0];
+            // UNMASKED_VENDOR_WEBGL
+            if (param === 37445) return 'Google Inc. (Apple)';
+            // UNMASKED_RENDERER_WEBGL
+            if (param === 37446) return 'ANGLE (Apple, Apple M2, OpenGL 4.1)';
+            return Reflect.apply(target, ctx, args);
+          }
+        };
+        const getParam = WebGLRenderingContext.prototype.getParameter;
+        WebGLRenderingContext.prototype.getParameter = new Proxy(getParam, getParameterProxyHandler);
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+          const getParam2 = WebGL2RenderingContext.prototype.getParameter;
+          WebGL2RenderingContext.prototype.getParameter = new Proxy(getParam2, getParameterProxyHandler);
+        }
+
+        // Canvas Spoofing (slight noise)
+        const originalFillText = CanvasRenderingContext2D.prototype.fillText;
+        CanvasRenderingContext2D.prototype.fillText = function(...args) {
+            if (!this._spoofing_applied) {
+                this._spoofing_applied = true;
+                const r = Math.random() * 0.0001;
+                const g = Math.random() * 0.0001;
+                const b = Math.random() * 0.0001;
+                this.fillStyle = \`rgba(\${Math.floor(r * 255)}, \${Math.floor(g * 255)}, \${Math.floor(b * 255)}, 0.01)\`;
+                originalFillText.call(this, "spoof", 0, 0);
+            }
+            return originalFillText.apply(this, args);
+        };
+
+        // Media Devices Spoofing
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+            navigator.mediaDevices.enumerateDevices = async () => {
+                return [
+                    { kind: 'audioinput', deviceId: 'default', groupId: 'a', label: 'MacBook Pro Microphone' },
+                    { kind: 'audiooutput', deviceId: 'default', groupId: 'b', label: 'MacBook Pro Speakers' },
+                    { kind: 'videoinput', deviceId: 'default', groupId: 'c', label: 'FaceTime HD Camera' }
+                ];
+            };
+        }
       })();
     `);
   }