neoagent 1.0.0

package/server/services/websocket.js

@@ -0,0 +1,191 @@
+const db = require('../db/database');
+const { sanitizeError } = require('../utils/security');
+
+function setupWebSocket(io, services) {
+  const { agentEngine, messagingManager, mcpClient, scheduler, memoryManager } = services;
+  io.on('connection', (socket) => {
+    const session = socket.request.session;
+    if (!session?.userId) {
+      socket.disconnect(true);
+      return;
+    }
+
+    const userId = session.userId;
+    socket.join(`user:${userId}`);
+
+    console.log(`[WS] User ${userId} connected (${socket.id})`);
+
+    // ── Agent Events ──
+
+    socket.on('agent:run', async (data) => {
+      try {
+        const { task, options } = data;
+        if (!task || typeof task !== 'string') return socket.emit('error', { message: 'Task must be a non-empty string' });
+        if (task.length > 50000) return socket.emit('error', { message: 'Message too long (max 50,000 characters)' });
+
+        if (task.startsWith('/')) {
+          const [rawCmd] = task.trim().split(/\s+/);
+          const cmd = rawCmd.slice(1).toLowerCase();
+
+          switch (cmd) {
+            case 'new':
+            case 'clear':
+              db.prepare('DELETE FROM conversation_history WHERE user_id = ?').run(userId);
+              socket.emit('chat:cleared');
+              {
+                const resetResult = await agentEngine.run(userId, 'context was just cleared. say something very brief (1-2 sentences max) acknowledging the fresh start, in your own style. no tools needed.', {});
+                socket.emit('run:complete', { content: resetResult?.content || 'fresh start.' });
+              }
+              return;
+
+            case 'stop': {
+              agentEngine.abortAll(userId);
+              const q = services.app?.locals?.userQueues;
+              if (q && q[userId]) { q[userId].pending = []; q[userId].running = false; }
+              socket.emit('run:complete', { content: 'Stopped.' });
+              return;
+            }
+
+            case 'help':
+              socket.emit('run:complete', {
+                content: '**Available commands**\n- `/new` or `/clear` — clear conversation context\n- `/stop` — abort all running tasks immediately\n- `/help` — show this message'
+              });
+              return;
+
+            default:
+              socket.emit('run:complete', { content: `Unknown command: \`/${cmd}\`. Type \`/help\` for available commands.` });
+              return;
+          }
+        }
+
+        db.prepare('INSERT INTO conversation_history (user_id, role, content, metadata) VALUES (?, ?, ?, ?)')
+          .run(userId, 'user', task, JSON.stringify({ platform: 'web' }));
+
+        const priorMessages = db.prepare(
+          'SELECT role, content FROM conversation_history WHERE user_id = ? ORDER BY created_at DESC LIMIT 30'
+        ).all(userId).reverse();
+        const prior = priorMessages.filter(m => !(m.role === 'user' && m.content === task)).slice(-29);
+
+        const result = await agentEngine.run(userId, task, { ...options, priorMessages: prior });
+
+        if (result?.content) {
+          db.prepare('INSERT INTO conversation_history (user_id, agent_run_id, role, content, metadata) VALUES (?, ?, ?, ?, ?)')
+            .run(userId, result.runId, 'assistant', result.content, JSON.stringify({ tokens: result.totalTokens }));
+        }
+      } catch (err) {
+        socket.emit('run:error', { error: sanitizeError(err) });
+      }
+    });
+
+    socket.on('agent:abort', (data) => {
+      try {
+        agentEngine.abort(data?.runId);
+        socket.emit('agent:aborted', { runId: data?.runId });
+      } catch (err) {
+        socket.emit('error', { message: sanitizeError(err) });
+      }
+    });
+
+    // ── Conversation ──
+
+    socket.on('agent:history', (data) => {
+      try {
+        const runs = db.prepare(
+          'SELECT * FROM agent_runs WHERE user_id = ? ORDER BY created_at DESC LIMIT ?'
+        ).all(userId, data?.limit || 20);
+        socket.emit('agent:history', runs);
+      } catch (err) {
+        socket.emit('error', { message: sanitizeError(err) });
+      }
+    });
+
+    socket.on('agent:run_detail', (data) => {
+      try {
+        const run = db.prepare('SELECT * FROM agent_runs WHERE id = ? AND user_id = ?').get(data.runId, userId);
+        const steps = db.prepare('SELECT * FROM agent_steps WHERE run_id = ? ORDER BY step_number ASC').all(data.runId);
+        const history = db.prepare('SELECT * FROM conversation_history WHERE agent_run_id = ? ORDER BY created_at ASC').all(data.runId);
+        socket.emit('agent:run_detail', { run, steps, history });
+      } catch (err) {
+        socket.emit('error', { message: sanitizeError(err) });
+      }
+    });
+
+    // ── Messaging ──
+
+    socket.on('messaging:connect', async (data) => {
+      try {
+        const result = await messagingManager.connectPlatform(userId, data.platform, data.config || {});
+        socket.emit('messaging:connect_result', result);
+      } catch (err) {
+        socket.emit('messaging:error', { error: sanitizeError(err) });
+      }
+    });
+
+    socket.on('messaging:disconnect', async (data) => {
+      try {
+        const result = await messagingManager.disconnectPlatform(userId, data.platform);
+        socket.emit('messaging:disconnect_result', result);
+      } catch (err) {
+        socket.emit('messaging:error', { error: sanitizeError(err) });
+      }
+    });
+
+    socket.on('messaging:send', async (data) => {
+      try {
+        const result = await messagingManager.sendMessage(userId, data.platform, data.to, data.content, data.mediaPath);
+        socket.emit('messaging:sent', result);
+      } catch (err) {
+        socket.emit('messaging:error', { error: sanitizeError(err) });
+      }
+    });
+
+    socket.on('messaging:status', () => {
+      try {
+        const statuses = messagingManager.getAllStatuses(userId);
+        socket.emit('messaging:status', statuses);
+      } catch (err) {
+        socket.emit('messaging:error', { error: sanitizeError(err) });
+      }
+    });
+
+    // ── MCP ──
+
+    socket.on('mcp:status', () => {
+      socket.emit('mcp:status', mcpClient.getStatus());
+    });
+
+    socket.on('mcp:tools', async (data) => {
+      try {
+        const tools = data?.serverId
+          ? await mcpClient.listTools(data.serverId)
+          : mcpClient.getAllTools();
+        socket.emit('mcp:tools', tools);
+      } catch (err) {
+        socket.emit('mcp:error', { error: sanitizeError(err) });
+      }
+    });
+
+    // ── Memory ──
+
+    socket.on('memory:read', () => {
+      socket.emit('memory:data', {
+        memory: memoryManager.readMemory(),
+        soul: memoryManager.readSoul(),
+        dailyLogs: memoryManager.listDailyLogs(3)
+      });
+    });
+
+    socket.on('memory:search', (data) => {
+      const results = memoryManager.searchMemory(data.query);
+      socket.emit('memory:search_results', results);
+    });
+
+    // ── Disconnect ──
+
+    socket.on('disconnect', () => {
+      console.log(`[WS] User ${userId} disconnected (${socket.id})`);
+    });
+  });
+}
+
+module.exports = { setupWebSocket };

package/server/utils/security.js

@@ -0,0 +1,71 @@
+/**
+ * Security utilities — shared helpers for input validation and output sanitization.
+ */
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const PROJECT_ROOT = require('path').join(__dirname, '../..');
+
+/**
+ * Strip internal filesystem paths and module stack frames from an error message
+ * before sending it to a client. Prevents leaking absolute paths, internal
+ * directory structure, or dependency internals in API responses.
+ */
+function sanitizeError(err) {
+  if (!err) return 'An unexpected error occurred';
+  const raw = typeof err === 'string' ? err : err.message || String(err);
+
+  let msg = raw;
+
+  // Replace home directory path with ~
+  if (HOME) {
+    msg = msg.split(HOME).join('~');
+  }
+
+  // Replace project root path with [app]
+  if (PROJECT_ROOT) {
+    msg = msg.split(PROJECT_ROOT).join('[app]');
+  }
+
+  // Strip node_modules paths
+  msg = msg.replace(/[^\s'"]+node_modules[^\s'"]+/g, '[module]');
+
+  // Strip remaining absolute Unix paths (leave relative paths intact)
+  msg = msg.replace(/\/[a-zA-Z0-9._-]+(?:\/[a-zA-Z0-9._-]+){2,}/g, '[path]');
+
+  // Strip Windows absolute paths
+  msg = msg.replace(/[A-Za-z]:\\[^\s'"]+/g, '[path]');
+
+  return msg.trim() || 'An unexpected error occurred';
+}
+
+/**
+ * Validate that a value is a plain string within an allowed length range.
+ */
+function validateString(value, { maxLength = 50000, name = 'value' } = {}) {
+  if (typeof value !== 'string') throw new Error(`${name} must be a string`);
+  if (value.length === 0) throw new Error(`${name} must not be empty`);
+  if (value.length > maxLength) throw new Error(`${name} exceeds maximum length of ${maxLength} characters`);
+  return value;
+}
+
+/**
+ * Returns true if the string looks like it contains a prompt injection attempt.
+ * This is a heuristic for logging/alerting — NOT a hard block (context window still applies).
+ */
+function detectPromptInjection(text) {
+  if (typeof text !== 'string') return false;
+  const patterns = [
+    /ignore\s+(all\s+)?previous\s+instructions/i,
+    /you\s+are\s+now\s+(DAN|GPT|jailbreak)/i,
+    /system\s+prompt\s*(override|bypass|end)/i,
+    /\[SYSTEM\]/i,
+    /###\s*(SYSTEM|OVERRIDE|NEW INSTRUCTIONS)/i,
+    /<\/?system>/i,
+    /reveal\s+(your\s+)?(system\s+)?prompt/i,
+    /act\s+as\s+if\s+you\s+have\s+no\s+(rules|restrictions|guidelines)/i,
+    /forget\s+(all\s+)?(previous|prior)\s+(instructions|context|training)/i,
+  ];
+  return patterns.some(p => p.test(text));
+}
+
+module.exports = { sanitizeError, validateString, detectPromptInjection };