neoagent 2.2.1-beta.6 → 2.2.1-beta.7

package/server/services/tasks/task_repository.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const db = require('../../db/database');
+
+class TaskRepository {
+  createTask(userId, normalizedTask) {
+    const result = db.prepare(
+      `INSERT INTO scheduled_tasks (
+        user_id, agent_id, name, trigger_type, trigger_config, cron_expression, run_at, one_time,
+        execution_mode, task_type, task_config, enabled
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      userId,
+      normalizedTask.agentId,
+      normalizedTask.name,
+      normalizedTask.triggerType,
+      JSON.stringify(normalizedTask.triggerConfig),
+      normalizedTask.legacyCronExpression,
+      normalizedTask.legacyRunAt,
+      normalizedTask.legacyOneTime ? 1 : 0,
+      normalizedTask.executionMode,
+      normalizedTask.taskType,
+      JSON.stringify(normalizedTask.taskConfig),
+      normalizedTask.enabled ? 1 : 0,
+    );
+    return result.lastInsertRowid;
+  }
+
+  updateTask(taskId, userId, normalizedTask) {
+    db.prepare(
+      `UPDATE scheduled_tasks
+       SET agent_id = ?, name = ?, trigger_type = ?, trigger_config = ?, cron_expression = ?, run_at = ?,
+           one_time = ?, execution_mode = ?, task_type = ?, task_config = ?, enabled = ?
+       WHERE id = ? AND user_id = ?`
+    ).run(
+      normalizedTask.agentId,
+      normalizedTask.name,
+      normalizedTask.triggerType,
+      JSON.stringify(normalizedTask.triggerConfig),
+      normalizedTask.legacyCronExpression,
+      normalizedTask.legacyRunAt,
+      normalizedTask.legacyOneTime ? 1 : 0,
+      normalizedTask.executionMode,
+      normalizedTask.taskType,
+      JSON.stringify(normalizedTask.taskConfig),
+      normalizedTask.enabled ? 1 : 0,
+      taskId,
+      userId,
+    );
+  }
+
+  deleteTask(taskId, userId) {
+    db.prepare('DELETE FROM scheduled_tasks WHERE id = ? AND user_id = ?').run(taskId, userId);
+  }
+
+  deleteById(taskId, userId) {
+    db.prepare('DELETE FROM scheduled_tasks WHERE id = ? AND user_id = ?').run(taskId, userId);
+  }
+
+  getTaskById(taskId, userId) {
+    return db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
+  }
+
+  listTasksForAgent(userId, agentId, includeLegacyMainTasks) {
+    return includeLegacyMainTasks
+      ? db.prepare(
+        `SELECT * FROM scheduled_tasks
+         WHERE user_id = ? AND (agent_id = ? OR agent_id IS NULL)
+         ORDER BY created_at DESC`
+      ).all(userId, agentId)
+      : db.prepare(
+        `SELECT * FROM scheduled_tasks
+         WHERE user_id = ? AND agent_id = ?
+         ORDER BY created_at DESC`
+      ).all(userId, agentId);
+  }
+
+  listEnabledTasks() {
+    return db.prepare('SELECT * FROM scheduled_tasks WHERE enabled = 1').all();
+  }
+
+  listDueOneTimeTasks() {
+    return db.prepare(
+      `SELECT * FROM scheduled_tasks
+       WHERE trigger_type = 'schedule'
+         AND one_time = 1
+         AND enabled = 1
+         AND run_at IS NOT NULL
+         AND run_at <= datetime('now')`
+    ).all();
+  }
+
+  listEnabledByTriggerTypes(triggerTypes) {
+    if (!Array.isArray(triggerTypes) || triggerTypes.length === 0) {
+      return [];
+    }
+    const placeholders = triggerTypes.map(() => '?').join(', ');
+    return db.prepare(
+      `SELECT * FROM scheduled_tasks
+       WHERE enabled = 1
+         AND trigger_type IN (${placeholders})`
+    ).all(...triggerTypes);
+  }
+
+  listEnabledWhatsappEventTasks(userId, agentId) {
+    return db.prepare(
+      `SELECT * FROM scheduled_tasks
+       WHERE enabled = 1 AND user_id = ? AND agent_id = ? AND trigger_type = 'whatsapp_personal_message_received'`
+    ).all(userId, agentId);
+  }
+
+  markTaskTriggered(taskId, userId, fingerprint) {
+    db.prepare(
+      `UPDATE scheduled_tasks
+       SET last_triggered_at = datetime('now'), last_trigger_fingerprint = ?
+       WHERE id = ? AND user_id = ?`
+    ).run(fingerprint, taskId, userId);
+  }
+
+  markTaskTriggerCheckpoint(taskId, fingerprint) {
+    db.prepare(
+      `UPDATE scheduled_tasks
+       SET last_triggered_at = datetime('now'), last_trigger_fingerprint = ?
+       WHERE id = ?`
+    ).run(fingerprint, taskId);
+  }
+
+  markTaskRun(taskId, userId) {
+    db.prepare('UPDATE scheduled_tasks SET last_run = datetime(\'now\') WHERE id = ? AND user_id = ?').run(taskId, userId);
+  }
+
+  updateTaskConfig(taskId, userId, taskConfig) {
+    db.prepare('UPDATE scheduled_tasks SET task_config = ? WHERE id = ? AND user_id = ?')
+      .run(JSON.stringify(taskConfig), taskId, userId);
+  }
+
+  getAgentSetting(userId, agentId, key) {
+    return db.prepare('SELECT value FROM agent_settings WHERE user_id = ? AND agent_id = ? AND key = ?')
+      .get(userId, agentId, key);
+  }
+
+  getUserSetting(userId, key) {
+    return db.prepare('SELECT value FROM user_settings WHERE user_id = ? AND key = ?')
+      .get(userId, key);
+  }
+
+  getTaskConversation(userId, agentId, platform, platformChatId) {
+    return db.prepare(
+      'SELECT id FROM conversations WHERE user_id = ? AND agent_id = ? AND platform = ? AND platform_chat_id = ?'
+    ).get(userId, agentId, platform, platformChatId);
+  }
+
+  createTaskConversation({ id, userId, agentId, platform, platformChatId, title }) {
+    db.prepare(
+      'INSERT INTO conversations (id, user_id, agent_id, platform, platform_chat_id, title) VALUES (?, ?, ?, ?, ?, ?)'
+    ).run(id, userId, agentId, platform, platformChatId, title);
+  }
+}
+
+module.exports = {
+  TaskRepository,
+};

package/server/services/tasks/trigger_registry.js

@@ -0,0 +1,29 @@
+'use strict';
+
+class TriggerRegistry {
+  constructor(adapters = []) {
+    this.adapters = new Map();
+    for (const adapter of adapters) {
+      this.register(adapter);
+    }
+  }
+
+  register(adapter) {
+    if (!adapter?.type) {
+      throw new Error('Trigger adapters must define a type.');
+    }
+    this.adapters.set(adapter.type, adapter);
+  }
+
+  get(type) {
+    return this.adapters.get(String(type || '').trim()) || null;
+  }
+
+  list() {
+    return Array.from(this.adapters.values());
+  }
+}
+
+module.exports = {
+  TriggerRegistry,
+};

package/server/services/tasks/utils.js

@@ -0,0 +1,45 @@
+'use strict';
+
+function normalizeJsonObject(value, fallback = {}) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return { ...fallback, ...value };
+  }
+  try {
+    const parsed = JSON.parse(String(value || '{}'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? { ...fallback, ...parsed }
+      : { ...fallback };
+  } catch {
+    return { ...fallback };
+  }
+}
+
+function stringifyJson(value) {
+  const normalized = normalizeJsonObject(value);
+  try {
+    return JSON.stringify(normalized);
+  } catch {
+    try {
+      const seen = new WeakSet();
+      return JSON.stringify(normalized, (_key, currentValue) => {
+        if (typeof currentValue === 'bigint') {
+          return currentValue.toString();
+        }
+        if (currentValue && typeof currentValue === 'object') {
+          if (seen.has(currentValue)) {
+            return '[Circular]';
+          }
+          seen.add(currentValue);
+        }
+        return currentValue;
+      });
+    } catch {
+      return JSON.stringify(String(value));
+    }
+  }
+}
+
+module.exports = {
+  normalizeJsonObject,
+  stringifyJson,
+};

package/server/services/websocket.js

@@ -160,7 +160,7 @@ function recordRateLimitHit(observer, userId, socketId, eventName, retryAfterMs)
 }
 
 function setupWebSocket(io, services) {
-  const { agentEngine, messagingManager, mcpClient, scheduler, memoryManager, voiceRuntimeManager } = services;
+  const { agentEngine, messagingManager, mcpClient, taskRuntime, memoryManager, voiceRuntimeManager } = services;
   const rateLimitObserver = createRateLimitObserver();
   const integrationManager =
     services.integrationManager || services.app?.locals?.integrationManager || null;

package/server/services/widgets/service.js

@@ -1,7 +1,7 @@
 const crypto = require('crypto');
 const db = require('../../db/database');
 const { resolveAgentId } = require('../agents/manager');
-const { getMinimumIntervalMinutes } = require('../scheduler/cron_utils');
+const { findNextRun, getMinimumIntervalMinutes } = require('../tasks/schedule_utils');
 
 const MIN_WIDGET_REFRESH_MINUTES = 60;
 
@@ -228,8 +228,8 @@ class WidgetService {
     this.app = app;
   }
 
-  get scheduler() {
-    return this.app?.locals?.scheduler || null;
+  get taskRuntime() {
+    return this.app?.locals?.taskRuntime || null;
   }
 
   get agentEngine() {
@@ -271,11 +271,11 @@ class WidgetService {
       .filter(Boolean);
   }
 
-  createWidget(userId, input = {}) {
+  async createWidget(userId, input = {}) {
     const normalized = normalizeWidgetInput(input, userId);
-    const scheduler = this.scheduler;
-    if (!scheduler) {
-      throw new Error('Scheduler not available.');
+    const taskRuntime = this.taskRuntime;
+    if (!taskRuntime) {
+      throw new Error('Task runtime not available.');
     }
     const widgetId = crypto.randomUUID();
 
@@ -302,9 +302,13 @@ class WidgetService {
 
     let task;
     try {
-      task = scheduler.createTask(userId, {
+      task = await taskRuntime.createTask(userId, {
         name: buildWidgetRefreshTaskName(normalized.name),
-        cronExpression: normalized.refreshCron,
+        triggerType: 'schedule',
+        triggerConfig: {
+          mode: 'recurring',
+          cronExpression: normalized.refreshCron,
+        },
         enabled: normalized.enabled,
         agentId: normalized.agentId,
         taskType: 'widget_refresh',
@@ -323,7 +327,7 @@ class WidgetService {
       ).run(task.id, widgetId, userId);
     } catch (error) {
       try {
-        scheduler.deleteTask(task.id, userId, { allowManaged: true });
+        taskRuntime.deleteTask(task.id, userId, { allowManaged: true });
       } catch {
         // Ignore cleanup failures and rethrow the original DB error.
       }
@@ -333,7 +337,7 @@ class WidgetService {
     return this.getWidget(userId, widgetId);
   }
 
-  updateWidget(userId, widgetId, input = {}) {
+  async updateWidget(userId, widgetId, input = {}) {
     const existingRow = db.prepare('SELECT * FROM ai_widgets WHERE id = ? AND user_id = ?').get(widgetId, userId);
     if (!existingRow) {
       throw new Error('Widget not found.');
@@ -353,9 +357,9 @@ class WidgetService {
       description: input.description,
     }, userId);
 
-    const scheduler = this.scheduler;
-    if (!scheduler) {
-      throw new Error('Scheduler not available.');
+    const taskRuntime = this.taskRuntime;
+    if (!taskRuntime) {
+      throw new Error('Task runtime not available.');
     }
 
     db.prepare('BEGIN').run();
@@ -378,12 +382,16 @@ class WidgetService {
       );
 
       if (existingRow.scheduled_task_id) {
-        scheduler.updateTask(
+        await taskRuntime.updateTask(
           existingRow.scheduled_task_id,
           userId,
           {
             name: buildWidgetRefreshTaskName(normalized.name),
-            cronExpression: normalized.refreshCron,
+            triggerType: 'schedule',
+            triggerConfig: {
+              mode: 'recurring',
+              cronExpression: normalized.refreshCron,
+            },
             enabled: normalized.enabled,
             agentId: normalized.agentId,
             taskConfig: { widgetId },
@@ -391,9 +399,13 @@ class WidgetService {
           { allowManaged: true },
         );
       } else {
-        const task = scheduler.createTask(userId, {
+        const task = await taskRuntime.createTask(userId, {
           name: buildWidgetRefreshTaskName(normalized.name),
-          cronExpression: normalized.refreshCron,
+          triggerType: 'schedule',
+          triggerConfig: {
+            mode: 'recurring',
+            cronExpression: normalized.refreshCron,
+          },
           enabled: normalized.enabled,
           agentId: normalized.agentId,
           taskType: 'widget_refresh',
@@ -411,7 +423,7 @@ class WidgetService {
       try {
         db.prepare('ROLLBACK').run();
       } catch {
-        // Ignore rollback failures and rethrow the original scheduler/DB error.
+        // Ignore rollback failures and rethrow the original task runtime/DB error.
       }
       throw error;
     }
@@ -425,10 +437,10 @@ class WidgetService {
       throw new Error('Widget not found.');
     }
 
-    const scheduler = this.scheduler;
+    const taskRuntime = this.taskRuntime;
     const tx = db.transaction(() => {
-      if (existingRow.scheduled_task_id && scheduler) {
-        scheduler.deleteTask(existingRow.scheduled_task_id, userId, { allowManaged: true });
+      if (existingRow.scheduled_task_id && taskRuntime) {
+        taskRuntime.deleteTask(existingRow.scheduled_task_id, userId, { allowManaged: true });
       }
       db.prepare('DELETE FROM ai_widget_snapshots WHERE widget_id = ?').run(widgetId);
       db.prepare('DELETE FROM ai_widgets WHERE id = ? AND user_id = ?').run(widgetId, userId);
@@ -484,8 +496,8 @@ class WidgetService {
     try {
       const prompt = this._buildRefreshPrompt(widget);
       const result = await engine.run(userId, prompt, {
-        triggerType: 'scheduler',
-        triggerSource: 'scheduler',
+        triggerType: 'schedule',
+        triggerSource: 'tasks',
         agentId: widget.agentId,
         app: this.app,
         taskId: options.taskId || widget.scheduledTaskId || null,
@@ -586,7 +598,7 @@ class WidgetService {
       lastError: row.last_error || null,
       createdAt: row.created_at || null,
       updatedAt: row.updated_at || null,
-      nextRefresh: row.refresh_cron ? this.scheduler?._getNextRun?.(row.refresh_cron) || null : null,
+      nextRefresh: row.refresh_cron ? findNextRun(row.refresh_cron)?.toISOString() || null : null,
       latestSnapshot,
     };
   }

package/server/routes/wearable_device.js

@@ -1,147 +0,0 @@
-'use strict';
-
-const express = require('express');
-const { sanitizeError } = require('../utils/security');
-const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
-const { wearableDeviceAuth } = require('../services/wearables/device_auth');
-const { createVoiceMessage } = require('../services/voice/message');
-
-const router = express.Router();
-
-router.post('/pairing/code', (req, res) => {
-  try {
-    const sessionUserId = req.session?.userId;
-    if (!sessionUserId) {
-      return res.status(401).json({ error: 'Authentication required' });
-    }
-    const agentId = resolveAgentId(sessionUserId, getAgentIdFromRequest(req));
-    const pairing = wearableDeviceAuth.createPairingCode(req.session.userId, {
-      agentId,
-      ttlMinutes: req.body?.ttlMinutes,
-      source: 'messaging_tab',
-      deviceHint: req.body?.deviceHint,
-    });
-    res.status(201).json(pairing);
-  } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
-  }
-});
-
-function extractBearerToken(req) {
-  const auth = String(req.get('authorization') || '');
-  if (!auth.toLowerCase().startsWith('bearer ')) return null;
-  return auth.slice(7).trim();
-}
-
-function requireWearableToken(req, res, next) {
-  const token = extractBearerToken(req);
-  if (!token) return res.status(401).json({ error: 'Missing bearer token' });
-  const tokenRow = wearableDeviceAuth.validateBearerToken(token);
-  if (!tokenRow) return res.status(401).json({ error: 'Invalid wearable token' });
-  wearableDeviceAuth.touchToken(tokenRow.id);
-  req.wearableToken = tokenRow;
-  next();
-}
-
-router.post('/pair/claim', (req, res) => {
-  try {
-    const code = String(req.body?.code || '').trim();
-    if (!code) return res.status(400).json({ error: 'code is required' });
-
-    const claimed = wearableDeviceAuth.claimPairingCode(code, {
-      deviceId: req.body?.deviceId,
-      deviceName: req.body?.deviceName,
-      macAddress: req.body?.macAddress,
-      protocol: req.body?.protocol,
-      firmwareVersion: req.body?.firmwareVersion,
-    });
-
-    res.status(201).json({
-      token: claimed.token,
-      tokenId: claimed.tokenId,
-      agentId: claimed.agentId,
-      deviceId: claimed.deviceId,
-      deviceName: claimed.deviceName,
-      protocol: claimed.protocol,
-    });
-  } catch (err) {
-    res.status(err.status || 500).json({ error: sanitizeError(err) });
-  }
-});
-
-router.post('/utterance', requireWearableToken, async (req, res) => {
-  try {
-    const token = req.wearableToken;
-    const text = String(req.body?.text || '').trim();
-    if (!text) return res.status(400).json({ error: 'text is required' });
-
-    const messagingManager = req.app.locals.messagingManager;
-    if (!messagingManager) {
-      return res.status(503).json({ error: 'Agent services unavailable' });
-    }
-
-    const chatId = token.device_id || token.id;
-    const message = createVoiceMessage({
-      platform: 'waveshare_wearable',
-      agentId: token.agent_id || null,
-      chatId,
-      sender: chatId,
-      senderName: token.device_name || 'NeoOS Wearable',
-      content: text,
-      mediaType: 'audio',
-      metadata: {
-        source: 'wearable_device_token',
-      },
-    });
-
-    await messagingManager.ingestMessage(
-      token.user_id,
-      'waveshare_wearable',
-      message,
-      { agentId: token.agent_id || null },
-    );
-
-    res.status(202).json({ success: true, accepted: true });
-  } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
-  }
-});
-
-router.get('/me', requireWearableToken, (req, res) => {
-  const token = req.wearableToken;
-  res.json({
-    deviceId: token.device_id,
-    name: token.device_name,
-    macAddress: token.mac_address,
-    protocol: token.protocol,
-    firmwareVersion: token.firmware_version,
-    lastSeenAt: token.last_seen_at,
-  });
-});
-
-router.get('/responses/next', requireWearableToken, (req, res) => {
-  try {
-    const token = req.wearableToken;
-    const limit = Number(req.query.limit || 5);
-    const responses = wearableDeviceAuth.getPendingResponses(token, limit);
-    res.json({ responses });
-  } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
-  }
-});
-
-router.post('/responses/ack', requireWearableToken, (req, res) => {
-  try {
-    const token = req.wearableToken;
-    const lastMessageId = Number(req.body?.lastMessageId || 0);
-    if (!Number.isFinite(lastMessageId) || lastMessageId <= 0) {
-      return res.status(400).json({ error: 'lastMessageId must be a positive number' });
-    }
-    wearableDeviceAuth.setLastCursor(token.id, lastMessageId);
-    res.json({ success: true, lastMessageId });
-  } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
-  }
-});
-
-module.exports = router;

package/server/services/messaging/waveshare_wearable.js

@@ -1,40 +0,0 @@
-const db = require('../../db/database');
-const { BasePlatform } = require('./base');
-const { wearableDeviceAuth } = require('../wearables/device_auth');
-
-class WaveshareWearablePlatform extends BasePlatform {
-  constructor(config = {}) {
-    super('waveshare_wearable', config);
-    this.supportsGroups = false;
-    this.supportsMedia = false;
-    this.supportsVoice = false;
-    this.status = 'disconnected';
-  }
-
-  async connect() {
-    this.status = 'connected';
-    this.emit('connected');
-  }
-
-  async disconnect() {
-    this.status = 'disconnected';
-    this.emit('disconnected', { reason: 'manual' });
-  }
-
-  async sendMessage() {
-    this.emit('message_sent');
-    return { queued: true };
-  }
-
-  getAuthInfo() {
-    return {
-      label: this.config?.deviceLabel || 'Wearable provisioning enabled',
-    };
-  }
-
-  listDevices(userId, options = {}) {
-    return wearableDeviceAuth.listDevicesForUser(userId, options);
-  }
-}
-
-module.exports = { WaveshareWearablePlatform };