neoagent 1.0.0

package/server/services/messaging/whatsapp.js

@@ -0,0 +1,304 @@
+const { BasePlatform } = require('./base');
+const path = require('path');
+const fs = require('fs');
+
+const AUTH_DIR = path.join(__dirname, '..', '..', '..', 'data', 'whatsapp-auth');
+
+class WhatsAppPlatform extends BasePlatform {
+  constructor(config = {}) {
+    super('whatsapp', config);
+    this.supportsGroups = true;
+    this.supportsMedia = true;
+    this.sock = null;
+    this.qrCode = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnect = 5;
+    this.authDir = config.authDir || AUTH_DIR;
+  }
+
+  async connect() {
+    if (!fs.existsSync(this.authDir)) fs.mkdirSync(this.authDir, { recursive: true });
+
+    const {
+      default: makeWASocket,
+      useMultiFileAuthState,
+      DisconnectReason,
+      makeCacheableSignalKeyStore,
+      fetchLatestBaileysVersion,
+      Browsers
+    } = require('@whiskeysockets/baileys');
+    const pino = require('pino');
+
+    let logger;
+    try {
+      logger = pino({ level: 'silent' });
+    } catch {
+      logger = { level: 'silent', info: () => {}, error: () => {}, warn: () => {}, debug: () => {}, trace: () => {}, child: () => logger };
+    }
+
+    const { version, isLatest } = await fetchLatestBaileysVersion();
+    console.log(`[WhatsApp] Using WA version ${version.join('.')}, isLatest: ${isLatest}`);
+
+    const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+
+    this._logger = logger;
+
+    this.sock = makeWASocket({
+      version,
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, logger)
+      },
+      logger,
+      browser: Browsers.appropriate('Chrome'),
+      connectTimeoutMs: 60000,
+      defaultQueryTimeoutMs: 60000,
+      markOnlineOnConnect: false,
+      generateHighQualityLinkPreview: false,
+      syncFullHistory: false,
+      fireInitQueries: false
+    });
+
+    this.sock.ev.on('creds.update', saveCreds);
+
+    this.sock.ev.on('connection.update', (update) => {
+      const { connection, lastDisconnect, qr } = update;
+
+      if (qr) {
+        this.qrCode = qr;
+        this.status = 'awaiting_qr';
+        this.emit('qr', qr);
+      }
+
+      if (connection === 'close') {
+        const statusCode = lastDisconnect?.error?.output?.statusCode;
+        const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
+
+        this.status = 'disconnected';
+        this.emit('disconnected', { statusCode, shouldReconnect });
+
+        if (shouldReconnect && this.reconnectAttempts < this.maxReconnect) {
+          this.reconnectAttempts++;
+          const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+          setTimeout(() => this.connect(), delay);
+        } else if (statusCode === DisconnectReason.loggedOut) {
+          fs.rmSync(this.authDir, { recursive: true, force: true });
+          this.emit('logged_out');
+        }
+      }
+
+      if (connection === 'open') {
+        this.status = 'connected';
+        this.qrCode = null;
+        this.reconnectAttempts = 0;
+        this.emit('connected');
+      }
+    });
+
+    this.sock.ev.on('messages.upsert', async ({ messages, type }) => {
+      if (type !== 'notify') return;
+
+      for (const msg of messages) {
+        if (msg.key.fromMe) continue;
+
+        const chatId = msg.key.remoteJid;
+        const isGroup = chatId?.endsWith('@g.us');
+        const sender = isGroup ? msg.key.participant : chatId;
+        const pushName = msg.pushName || '';
+
+        let content = '';
+        let mediaType = null;
+
+        if (msg.message?.conversation) {
+          content = msg.message.conversation;
+        } else if (msg.message?.extendedTextMessage?.text) {
+          content = msg.message.extendedTextMessage.text;
+        } else if (msg.message?.imageMessage) {
+          content = msg.message.imageMessage.caption || '[Image]';
+          mediaType = 'image';
+        } else if (msg.message?.videoMessage) {
+          content = msg.message.videoMessage.caption || '[Video]';
+          mediaType = 'video';
+        } else if (msg.message?.audioMessage) {
+          content = '[Voice Note]';
+          mediaType = 'audio';
+        } else if (msg.message?.documentMessage) {
+          content = msg.message.documentMessage.fileName || '[Document]';
+          mediaType = 'document';
+        } else if (msg.message?.stickerMessage) {
+          content = '[Sticker]';
+          mediaType = 'sticker';
+        }
+
+        if (!content && !mediaType) continue;
+
+        let localMediaPath = null;
+        if (mediaType && mediaType !== 'sticker') {
+          try {
+            const { downloadMediaMessage } = require('@whiskeysockets/baileys');
+            const MEDIA_DIR = path.join(__dirname, '..', '..', '..', 'data', 'media');
+            if (!fs.existsSync(MEDIA_DIR)) fs.mkdirSync(MEDIA_DIR, { recursive: true });
+            const buffer = await downloadMediaMessage(msg, 'buffer', {}, {
+              logger: this._logger,
+              reuploadRequest: this.sock.updateMediaMessage
+            });
+            const extMap = { image: 'jpg', video: 'mp4', document: 'bin', audio: 'ogg' };
+            const ext = extMap[mediaType] || 'bin';
+            const safeId = (msg.key.id || 'file').replace(/[^a-zA-Z0-9]/g, '');
+            const fname = `${Date.now()}_${safeId}.${ext}`;
+            localMediaPath = path.join(MEDIA_DIR, fname);
+            fs.writeFileSync(localMediaPath, buffer);
+
+            // Transcribe WhatsApp voice notes using OpenAI Whisper
+            if (mediaType === 'audio' && process.env.OPENAI_API_KEY) {
+              try {
+                const OpenAI = require('openai');
+                const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+                const transcription = await openai.audio.transcriptions.create({
+                  file: fs.createReadStream(localMediaPath),
+                  model: 'whisper-1',
+                  response_format: 'text'
+                });
+                content = (typeof transcription === 'string' ? transcription : transcription?.text || '').trim() || '[Voice Note - empty audio]';
+                console.log(`[WhatsApp] Voice note transcribed: "${content.slice(0, 80)}"`);
+              } catch (transcribeErr) {
+                console.error('[WhatsApp] Audio transcription failed:', transcribeErr.message);
+                content = '[Voice Note - transcription failed]';
+              }
+            }
+          } catch (dlErr) {
+            console.error('[WhatsApp] Media download failed:', dlErr.message);
+          }
+        }
+
+        try {
+          await this.sock.readMessages([msg.key]);
+        } catch { /* non-fatal */ }
+
+        this.emit('message', {
+          platform: 'whatsapp',
+          chatId,
+          sender,
+          senderName: pushName,
+          content,
+          mediaType,
+          localMediaPath,
+          isGroup,
+          messageId: msg.key.id,
+          timestamp: msg.messageTimestamp ? new Date(msg.messageTimestamp * 1000).toISOString() : new Date().toISOString(),
+          rawMessage: msg
+        });
+      }
+    });
+
+    return { status: this.status };
+  }
+
+  async disconnect() {
+    if (this.sock) {
+      this.sock.end();
+      this.sock = null;
+    }
+    this.status = 'disconnected';
+    this.emit('disconnected', { manual: true });
+  }
+
+  async sendMessage(to, content, options = {}) {
+    if (!this.sock || this.status !== 'connected') {
+      throw new Error('WhatsApp not connected');
+    }
+
+    let jid = to;
+    if (!jid.includes('@')) {
+      jid = jid.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+    }
+
+    if (options.mediaPath) {
+      const ext = path.extname(options.mediaPath).toLowerCase();
+      if (['.jpg', '.jpeg', '.png', '.gif', '.webp'].includes(ext)) {
+        return await this.sock.sendMessage(jid, {
+          image: fs.readFileSync(options.mediaPath),
+          caption: content || undefined
+        });
+      } else if (['.mp4', '.avi', '.mov'].includes(ext)) {
+        return await this.sock.sendMessage(jid, {
+          video: fs.readFileSync(options.mediaPath),
+          caption: content || undefined
+        });
+      } else if (['.mp3', '.ogg', '.m4a'].includes(ext)) {
+        return await this.sock.sendMessage(jid, {
+          audio: fs.readFileSync(options.mediaPath),
+          mimetype: 'audio/mp4'
+        });
+      } else {
+        return await this.sock.sendMessage(jid, {
+          document: fs.readFileSync(options.mediaPath),
+          fileName: path.basename(options.mediaPath),
+          caption: content || undefined
+        });
+      }
+    }
+
+    return await this.sock.sendMessage(jid, { text: content });
+  }
+
+  async markRead(chatId, messageId) {
+    if (!this.sock) return;
+    let jid = chatId;
+    if (!jid.includes('@')) jid = jid + '@s.whatsapp.net';
+    // readMessages expects full message keys; we do a best-effort read
+    await this.sock.sendReadReceipt(jid, null, [messageId]).catch(() => {});
+  }
+
+  async sendTyping(chatId, isTyping) {
+    if (!this.sock || this.status !== 'connected') return;
+    let jid = chatId;
+    if (!jid.includes('@')) jid = jid + '@s.whatsapp.net';
+    await this.sock.sendPresenceUpdate(isTyping ? 'composing' : 'paused', jid).catch(() => {});
+  }
+
+  async getContacts() {
+    if (!this.sock) return [];
+    try {
+      const contacts = await this.sock.store?.contacts || {};
+      return Object.entries(contacts).map(([id, contact]) => ({
+        id,
+        name: contact.name || contact.notify || id.split('@')[0],
+        isGroup: id.endsWith('@g.us')
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async getChats() {
+    if (!this.sock) return [];
+    try {
+      const chats = await this.sock.groupFetchAllParticipating();
+      return Object.entries(chats).map(([id, chat]) => ({
+        id,
+        name: chat.subject || id,
+        isGroup: true,
+        participants: chat.participants?.length || 0
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  getAuthInfo() {
+    return { qrCode: this.qrCode, status: this.status };
+  }
+
+  async logout() {
+    if (this.sock) {
+      await this.sock.logout();
+      this.sock = null;
+    }
+    fs.rmSync(this.authDir, { recursive: true, force: true });
+    this.status = 'disconnected';
+    this.qrCode = null;
+  }
+}
+
+module.exports = { WhatsAppPlatform };

package/server/services/scheduler/cron.js

@@ -0,0 +1,312 @@
+const cron = require('node-cron');
+const crypto = require('crypto');
+const db = require('../../db/database');
+
+class Scheduler {
+  constructor(io, agentEngine) {
+    this.io = io;
+    this.agentEngine = agentEngine;
+    this.jobs = new Map();
+    this.heartbeatJob = null;
+  }
+
+  start() {
+    this._loadFromDB();
+    this._startHeartbeat();
+    this._startOneTimePoller();
+    console.log('[Scheduler] Started');
+  }
+
+  stop() {
+    for (const [id, job] of this.jobs) {
+      job.task.stop();
+    }
+    this.jobs.clear();
+    if (this.heartbeatJob) {
+      this.heartbeatJob.stop();
+      this.heartbeatJob = null;
+    }
+    if (this.oneTimePoller) {
+      this.oneTimePoller.stop();
+      this.oneTimePoller = null;
+    }
+    console.log('[Scheduler] Stopped');
+  }
+
+  _startHeartbeat() {
+    // Heartbeat runs every 5 minutes
+    this.heartbeatJob = cron.schedule('*/5 * * * *', async () => {
+      try {
+        await this._runHeartbeat();
+      } catch (err) {
+        console.error('[Heartbeat] Error:', err.message);
+      }
+    });
+    console.log('[Scheduler] Heartbeat active (every 5 min)');
+  }
+
+  _startOneTimePoller() {
+    this.oneTimePoller = cron.schedule('* * * * *', async () => {
+      const due = db.prepare(
+        `SELECT * FROM scheduled_tasks WHERE one_time = 1 AND enabled = 1 AND run_at IS NOT NULL AND run_at <= datetime('now')`
+      ).all();
+
+      for (const task of due) {
+        const config = JSON.parse(task.task_config || '{}');
+        // Remove from memory before executing so a slow run can't double-fire
+        this.jobs.delete(task.id);
+        try {
+          await this._executeTask(task.id, task.user_id, config);
+        } catch (err) {
+          console.error(`[Scheduler] One-time task ${task.id} error:`, err.message);
+        }
+        // Auto-delete after execution
+        db.prepare('DELETE FROM scheduled_tasks WHERE id = ?').run(task.id);
+        this.io.to(`user:${task.user_id}`).emit('scheduler:task_deleted', { taskId: task.id });
+      }
+    });
+    console.log('[Scheduler] One-time poller active (every 1 min)');
+  }
+
+  async _runHeartbeat() {
+    const users = db.prepare('SELECT id FROM users').all();
+
+    for (const user of users) {
+      const settings = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(user.id, 'heartbeat_enabled');
+
+      if (!settings || settings.value !== 'true') continue;
+
+      const prompt = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+        .get(user.id, 'heartbeat_prompt');
+
+      const defaultPrompt = 'You are running a silent background heartbeat check. Scan memory, pending tasks, and reminders. DEFAULT ACTION IS SILENCE — do NOT contact the user unless something is genuinely important (urgent deadline, critical failure, time-sensitive action required, or something the user would be upset to miss). If nothing important is found, do nothing and end the run quietly. Never send routine updates, summaries, or "all clear" messages.';
+
+      const lastPlatform = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(user.id, 'last_platform')?.value;
+      const lastChatId = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(user.id, 'last_chat_id')?.value;
+      const platformHint = lastPlatform && lastChatId
+        ? `\n\nOnly if you found something that genuinely requires the user's attention, send_message to platform="${lastPlatform}" to="${lastChatId}". Otherwise stay silent.`
+        : '';
+
+      this.io.to(`user:${user.id}`).emit('heartbeat:running', { timestamp: new Date().toISOString() });
+
+      try {
+        if (this.agentEngine) {
+          const convId = this._getMessagingConversation(user.id);
+
+          await this.agentEngine.run(user.id, (prompt?.value || defaultPrompt) + platformHint, {
+            triggerSource: 'heartbeat',
+            ...(convId ? { conversationId: convId } : {}),
+          });
+        }
+      } catch (err) {
+        console.error(`[Heartbeat] Error for user ${user.id}:`, err.message);
+      }
+    }
+  }
+
+  createTask(userId, { name, cronExpression, prompt, enabled = true, callTo = null, callGreeting = null, runAt = null, oneTime = false }) {
+    if (oneTime) {
+      if (!runAt) throw new Error('runAt is required for one-time tasks');
+      const runAtDate = new Date(runAt);
+      if (isNaN(runAtDate.getTime())) throw new Error(`Invalid runAt value: ${runAt}`);
+
+      const config = { prompt };
+      if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
+
+      const result = db.prepare(
+        'INSERT INTO scheduled_tasks (user_id, name, cron_expression, run_at, one_time, task_type, task_config, enabled) VALUES (?, ?, NULL, ?, 1, ?, ?, ?)'
+      ).run(userId, name, runAtDate.toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''), 'agent_prompt', JSON.stringify(config), enabled ? 1 : 0);
+
+      return { id: result.lastInsertRowid, name, runAt: runAtDate.toISOString(), oneTime: true, enabled };
+    }
+
+    if (!cronExpression || !cron.validate(cronExpression)) {
+      throw new Error(`Invalid cron expression: ${cronExpression}`);
+    }
+
+    const config = { prompt };
+    if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
+
+    const result = db.prepare(
+      'INSERT INTO scheduled_tasks (user_id, name, cron_expression, task_type, task_config, enabled) VALUES (?, ?, ?, ?, ?, ?)'
+    ).run(userId, name, cronExpression, 'agent_prompt', JSON.stringify(config), enabled ? 1 : 0);
+
+    const taskId = result.lastInsertRowid;
+
+    if (enabled) {
+      this._scheduleTask(taskId, userId, cronExpression, config);
+    }
+
+    return { id: taskId, name, cronExpression, enabled, callTo: config.callTo || null };
+  }
+
+  updateTask(taskId, userId, updates) {
+    const task = db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
+    if (!task) throw new Error('Task not found');
+
+    const name = updates.name || task.name;
+    const cronExpr = updates.cronExpression || task.cron_expression;
+    const enabled = updates.enabled !== undefined ? updates.enabled : task.enabled;
+
+    // Merge config — start from existing, apply any changes
+    let config = JSON.parse(task.task_config || '{}');
+    if (updates.prompt !== undefined) config.prompt = updates.prompt;
+    if (updates.callTo !== undefined) config.callTo = updates.callTo || null;
+    if (updates.callGreeting !== undefined) config.callGreeting = updates.callGreeting || null;
+    // Clean up nulls
+    if (!config.callTo) { delete config.callTo; delete config.callGreeting; }
+
+    if (updates.cronExpression && !cron.validate(updates.cronExpression)) {
+      throw new Error(`Invalid cron expression: ${updates.cronExpression}`);
+    }
+
+    db.prepare('UPDATE scheduled_tasks SET name = ?, cron_expression = ?, task_config = ?, enabled = ? WHERE id = ?')
+      .run(name, cronExpr, JSON.stringify(config), enabled ? 1 : 0, taskId);
+
+    // Reschedule
+    const existing = this.jobs.get(taskId);
+    if (existing) {
+      existing.task.stop();
+      this.jobs.delete(taskId);
+    }
+
+    if (enabled) {
+      this._scheduleTask(taskId, userId, cronExpr, config);
+    }
+
+    return { id: taskId, name, cronExpression: cronExpr, enabled, callTo: config.callTo || null };
+  }
+
+  deleteTask(taskId, userId) {
+    const task = db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
+    if (!task) throw new Error('Task not found');
+
+    const existing = this.jobs.get(taskId);
+    if (existing) {
+      existing.task.stop();
+      this.jobs.delete(taskId);
+    }
+
+    db.prepare('DELETE FROM scheduled_tasks WHERE id = ?').run(taskId);
+    return { deleted: true };
+  }
+
+  listTasks(userId) {
+    const tasks = db.prepare('SELECT * FROM scheduled_tasks WHERE user_id = ? ORDER BY created_at DESC').all(userId);
+    return tasks.map(t => ({
+      id: t.id,
+      name: t.name,
+      cronExpression: t.cron_expression,
+      runAt: t.run_at || null,
+      oneTime: !!t.one_time,
+      enabled: !!t.enabled,
+      lastRun: t.last_run,
+      nextRun: t.one_time ? t.run_at : this._getNextRun(t.cron_expression),
+      config: JSON.parse(t.task_config || '{}')
+    }));
+  }
+
+  runTaskNow(taskId, userId) {
+    const task = db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
+    if (!task) throw new Error('Task not found');
+
+    const config = JSON.parse(task.task_config || '{}');
+    this._executeTask(taskId, userId, config);
+    return { running: true };
+  }
+
+  _scheduleTask(taskId, userId, cronExpression, config) {
+    const task = cron.schedule(cronExpression, async () => {
+      await this._executeTask(taskId, userId, config);
+    });
+
+    this.jobs.set(taskId, { task, userId, config });
+  }
+
+  async _executeTask(taskId, userId, config) {
+    db.prepare('UPDATE scheduled_tasks SET last_run = datetime(\'now\') WHERE id = ?').run(taskId);
+
+    this.io.to(`user:${userId}`).emit('scheduler:task_running', { taskId, timestamp: new Date().toISOString() });
+
+    try {
+      if (this.agentEngine && config.prompt) {
+        let notifyHint = '';
+
+        if (config.callTo) {
+          notifyHint = `\n\nThis task is configured to notify the user by phone. Use the make_call tool to call "${config.callTo}" with an appropriate greeting based on your findings. The configured greeting hint is: "${config.callGreeting || 'Hello, this is your scheduled reminder.'}"`;
+        } else {
+          const lastPlatform = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(userId, 'last_platform')?.value;
+          const lastChatId = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(userId, 'last_chat_id')?.value;
+          notifyHint = lastPlatform && lastChatId
+            ? `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${lastPlatform}" to="${lastChatId}".`
+            : '';
+        }
+
+        const convId = this._getMessagingConversation(userId);
+
+        const result = await this.agentEngine.run(userId, config.prompt + notifyHint, {
+          triggerSource: 'scheduler',
+          ...(convId ? { conversationId: convId } : {}),
+          taskId,
+        });
+        this.io.to(`user:${userId}`).emit('scheduler:task_complete', { taskId, result });
+      }
+    } catch (err) {
+      console.error(`[Scheduler] Task ${taskId} error:`, err.message);
+      this.io.to(`user:${userId}`).emit('scheduler:task_error', { taskId, error: err.message });
+    }
+  }
+
+  _loadFromDB() {
+    const tasks = db.prepare('SELECT * FROM scheduled_tasks WHERE enabled = 1').all();
+    let loaded = 0;
+    for (const task of tasks) {
+      try {
+        const config = JSON.parse(task.task_config || '{}');
+        if (task.one_time) {
+          // One-time tasks are handled by the poller; nothing to register here
+          // But if it's already past due when we restart, the poller will catch it in <1 min
+        } else if (task.cron_expression) {
+          this._scheduleTask(task.id, task.user_id, task.cron_expression, config);
+          loaded++;
+        }
+      } catch (err) {
+        console.error(`[Scheduler] Failed to load task ${task.id}:`, err.message);
+      }
+    }
+    console.log(`[Scheduler] Loaded ${loaded} recurring tasks from DB`);
+  }
+
+  _getNextRun(cronExpression) {
+    try {
+      const interval = cron.schedule(cronExpression, () => { });
+      interval.stop();
+      // node-cron doesn't expose nextRun; we just return null
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  _getMessagingConversation(userId) {
+    const lastPlatform = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(userId, 'last_platform')?.value;
+    const lastChatId = db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?').get(userId, 'last_chat_id')?.value;
+    if (!lastPlatform || !lastChatId) return null;
+
+    let convRow = db.prepare(
+      'SELECT id FROM conversations WHERE user_id = ? AND platform = ? AND platform_chat_id = ?'
+    ).get(userId, lastPlatform, lastChatId);
+
+    if (!convRow) {
+      const convId = crypto.randomUUID();
+      db.prepare(
+        'INSERT INTO conversations (id, user_id, platform, platform_chat_id, title) VALUES (?, ?, ?, ?, ?)'
+      ).run(convId, userId, lastPlatform, lastChatId, `${lastPlatform} — ${lastChatId}`);
+      convRow = { id: convId };
+    }
+
+    return convRow.id;
+  }
+}
+
+module.exports = { Scheduler };