neoagent 2.4.2-beta.4 → 2.4.2-beta.6

package/server/services/memory/manager.js

@@ -932,13 +932,44 @@ class MemoryManager {
       this._deleteMemoryIndex(memoryId);
 
       for (const fact of facts) {
+        const factId = uuidv4();
+        const validFrom = fact.eventTime
+          || metadata?.validFrom
+          || metadata?.eventTime
+          || null;
+        const conflict = fact.predicate === 'detail'
+          ? null
+          : db.prepare(
+            `SELECT id, object
+             FROM memory_facts
+             WHERE user_id = ? AND agent_id = ?
+               AND lower(subject) = lower(?)
+               AND lower(predicate) = lower(?)
+               AND status = 'active'
+             ORDER BY learned_at DESC, created_at DESC
+             LIMIT 1`
+          ).get(userId, agentId, fact.subject, fact.predicate);
+        const supersedesFactId = conflict && String(conflict.object) !== String(fact.object)
+          ? conflict.id
+          : null;
+        if (supersedesFactId) {
+          db.prepare(
+            `UPDATE memory_facts
+             SET status = 'superseded',
+                 valid_to = COALESCE(?, datetime('now')),
+                 invalidated_at = datetime('now'),
+                 updated_at = datetime('now')
+             WHERE id = ?`
+          ).run(validFrom, supersedesFactId);
+        }
         db.prepare(
           `INSERT INTO memory_facts (
             id, memory_id, user_id, agent_id, subject, predicate, object, category,
-            confidence, event_time, metadata_json, created_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))`
+            confidence, event_time, valid_from, learned_at, status, supersedes_fact_id,
+            metadata_json, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, datetime('now'), datetime('now'))`
         ).run(
-          uuidv4(),
+          factId,
           memoryId,
           userId,
           agentId,
@@ -948,6 +979,9 @@ class MemoryManager {
           normalizeMemoryCategory(fact.category),
           Math.max(0, Math.min(1, Number(fact.confidence) || 0.7)),
           fact.eventTime || null,
+          validFrom,
+          now,
+          supersedesFactId,
           JSON.stringify(parseJsonObject(fact.metadata, {})),
         );
       }
@@ -1229,7 +1263,7 @@ class MemoryManager {
     const scope = normalizeScope(options.scope, agentId);
     const limit = Math.max(1, Math.min(Number(topK) || 6, 50));
 
-    const all = db.prepare(
+    let all = db.prepare(
       `SELECT id, category, content, summary, importance, confidence, embedding, access_count, created_at, updated_at,
               scope_type, scope_id, source_type, source_id, source_label, stale_after_days, metadata_json
        FROM memories
@@ -1242,6 +1276,30 @@ class MemoryManager {
        LIMIT 800`
     ).all(userId, agentId, scope.scopeType, scope.scopeId);
 
+    const validAt = String(options.validAt || options.at || '').trim();
+    const knownAt = String(options.knownAt || '').trim();
+    if (validAt || knownAt) {
+      const eligibleRows = db.prepare(
+        `SELECT DISTINCT memory_id
+         FROM memory_facts
+         WHERE user_id = ? AND agent_id = ?
+           AND (? = '' OR COALESCE(valid_from, event_time, created_at) <= ?)
+           AND (? = '' OR valid_to IS NULL OR valid_to > ?)
+           AND (? = '' OR COALESCE(learned_at, created_at) <= ?)`
+      ).all(
+        userId,
+        agentId,
+        validAt,
+        validAt,
+        validAt,
+        validAt,
+        knownAt,
+        knownAt,
+      );
+      const eligibleIds = new Set(eligibleRows.map((row) => row.memory_id));
+      all = all.filter((memory) => eligibleIds.has(memory.id));
+    }
+
     if (!all.length) return [];
 
     const queryVec = await getEmbedding(query, await getActiveProvider(userId, agentId));
@@ -1444,6 +1502,9 @@ class MemoryManager {
   }
 
   updateCore(userId, key, value, options = {}) {
+    if (options.confirmed !== true) {
+      throw new Error('Core memory updates require explicit confirmation.');
+    }
     const agentId = this._agentId(userId, options);
     const strVal = typeof value === 'object' ? JSON.stringify(value) : String(value);
     db.prepare(
@@ -1458,6 +1519,111 @@ class MemoryManager {
     db.prepare(`DELETE FROM core_memory WHERE user_id = ? AND agent_id = ? AND key = ?`).run(userId, agentId, key);
   }
 
+  listFacts(userId, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const status = String(options.status || '').trim();
+    const subject = String(options.subject || '').trim();
+    const predicate = String(options.predicate || '').trim();
+    const validAt = String(options.validAt || '').trim();
+    const knownAt = String(options.knownAt || '').trim();
+    const limit = Math.max(1, Math.min(Number(options.limit) || 100, 500));
+    return db.prepare(
+      `SELECT
+         f.id, f.memory_id, f.subject, f.predicate, f.object, f.category,
+         f.confidence, f.event_time, f.valid_from, f.valid_to, f.learned_at,
+         f.invalidated_at, f.status, f.supersedes_fact_id, f.metadata_json,
+         f.created_at, f.updated_at,
+         m.source_type, m.source_id, m.source_label
+       FROM memory_facts f
+       JOIN memories m ON m.id = f.memory_id
+       WHERE f.user_id = ? AND f.agent_id = ?
+         AND (? = '' OR f.status = ?)
+         AND (? = '' OR lower(f.subject) = lower(?))
+         AND (? = '' OR lower(f.predicate) = lower(?))
+         AND (? = '' OR COALESCE(f.valid_from, f.event_time, f.created_at) <= ?)
+         AND (? = '' OR f.valid_to IS NULL OR f.valid_to > ?)
+         AND (? = '' OR COALESCE(f.learned_at, f.created_at) <= ?)
+       ORDER BY COALESCE(f.learned_at, f.created_at) DESC
+       LIMIT ?`
+    ).all(
+      userId,
+      agentId,
+      status,
+      status,
+      subject,
+      subject,
+      predicate,
+      predicate,
+      validAt,
+      validAt,
+      validAt,
+      validAt,
+      knownAt,
+      knownAt,
+      limit,
+    ).map((row) => ({
+      id: row.id,
+      memoryId: row.memory_id,
+      subject: row.subject,
+      predicate: row.predicate,
+      object: row.object,
+      category: row.category,
+      confidence: Number(row.confidence || 0),
+      eventTime: row.event_time || null,
+      validFrom: row.valid_from || null,
+      validTo: row.valid_to || null,
+      learnedAt: row.learned_at || row.created_at,
+      invalidatedAt: row.invalidated_at || null,
+      status: row.status || 'active',
+      supersedesFactId: row.supersedes_fact_id || null,
+      sourceRef: {
+        sourceType: row.source_type || null,
+        sourceId: row.source_id || null,
+        sourceLabel: row.source_label || null,
+      },
+      metadata: parseJsonObject(row.metadata_json, {}),
+    }));
+  }
+
+  reconcileFacts(userId, options = {}) {
+    const agentId = this._agentId(userId, options);
+    const minimumConfidence = Math.min(Math.max(Number(options.minimumConfidence ?? 0.35), 0), 1);
+    const now = new Date().toISOString();
+    const expired = db.prepare(
+      `UPDATE memory_facts
+       SET status = 'expired', invalidated_at = COALESCE(invalidated_at, datetime('now')),
+           updated_at = datetime('now')
+       WHERE user_id = ? AND agent_id = ? AND status = 'active'
+         AND valid_to IS NOT NULL AND valid_to <= ?`
+    ).run(userId, agentId, now).changes;
+    const lowConfidence = db.prepare(
+      `UPDATE memory_facts
+       SET status = 'review', updated_at = datetime('now')
+       WHERE user_id = ? AND agent_id = ? AND status = 'active' AND confidence < ?`
+    ).run(userId, agentId, minimumConfidence).changes;
+    const duplicates = db.prepare(
+      `SELECT subject, predicate, object, GROUP_CONCAT(id) AS ids, COUNT(*) AS count
+       FROM memory_facts
+       WHERE user_id = ? AND agent_id = ? AND status = 'active'
+       GROUP BY lower(subject), lower(predicate), lower(object)
+       HAVING COUNT(*) > 1`
+    ).all(userId, agentId);
+    let invalidatedDuplicates = 0;
+    for (const group of duplicates) {
+      const ids = String(group.ids || '').split(',').filter(Boolean);
+      const keep = ids.pop();
+      for (const id of ids) {
+        invalidatedDuplicates += db.prepare(
+          `UPDATE memory_facts
+           SET status = 'duplicate', invalidated_at = datetime('now'),
+               supersedes_fact_id = COALESCE(supersedes_fact_id, ?), updated_at = datetime('now')
+           WHERE id = ?`
+        ).run(keep, id).changes;
+      }
+    }
+    return { expired, lowConfidence, invalidatedDuplicates };
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // Conversation State
   // ─────────────────────────────────────────────────────────────────────────

package/server/services/security/capability_audit.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const path = require('path');
+const db = require('../../db/database');
+const { AGENT_DATA_DIR } = require('../../../runtime/paths');
+
+const SKILLS_ROOT = path.resolve(AGENT_DATA_DIR, 'skills');
+const SECRET_KEY = /(^|_)(secret|token|password|api_key|private_key)($|_)/i;
+const SHELL_METACHAR_RE = /[;&|`$\n\r(){}\\<>]/;
+
+function walkObject(value, visitor, currentPath = '') {
+  if (!value || typeof value !== 'object') return;
+  for (const [key, child] of Object.entries(value)) {
+    const nextPath = currentPath ? `${currentPath}.${key}` : key;
+    visitor(key, child, nextPath);
+    walkObject(child, visitor, nextPath);
+  }
+}
+
+class CapabilityAuditService {
+  constructor(options = {}) {
+    this.mcpClient = options.mcpClient;
+    this.skillRunner = options.skillRunner;
+  }
+
+  auditMcp(userId, options = {}) {
+    const rows = db.prepare(
+      'SELECT id, name, command, config, enabled FROM mcp_servers WHERE user_id = ?'
+    ).all(userId);
+    return rows.map((row) => {
+      const findings = [];
+      let config = {};
+      try { config = JSON.parse(row.config || '{}'); } catch {
+        findings.push({ severity: 'high', code: 'invalid_config_json', message: 'Configuration is not valid JSON.' });
+      }
+      walkObject(config, (key, value, fieldPath) => {
+        if (SECRET_KEY.test(key) && typeof value === 'string' && value && !value.startsWith('enc:v1:')) {
+          findings.push({
+            severity: 'high',
+            code: 'plaintext_secret',
+            message: `Sensitive field ${fieldPath} is stored without application encryption.`,
+          });
+        }
+      });
+      try {
+        const endpoint = new URL(row.command);
+        if (!['https:', 'http:'].includes(endpoint.protocol)) {
+          findings.push({ severity: 'high', code: 'unsupported_transport', message: 'MCP endpoint uses an unsupported protocol.' });
+        }
+      } catch {
+        findings.push({ severity: 'high', code: 'invalid_endpoint', message: 'MCP endpoint is not a valid URL.' });
+      }
+      const tools = this.mcpClient?.getAllTools?.(userId, options) || [];
+      for (const tool of tools.filter((item) => Number(item.serverId) === Number(row.id))) {
+        if (!tool.name || !tool.inputSchema || tool.inputSchema.type !== 'object') {
+          findings.push({
+            severity: 'medium',
+            code: 'invalid_tool_schema',
+            message: `Tool ${tool.name || 'unknown'} does not expose a valid object input schema.`,
+          });
+        }
+      }
+      return {
+        id: row.id,
+        name: row.name,
+        enabled: Boolean(row.enabled),
+        findingCount: findings.length,
+        findings,
+      };
+    });
+  }
+
+  auditSkills() {
+    return Array.from(this.skillRunner?.skills?.values?.() || []).map((skill) => {
+      const findings = [];
+      const resolvedPath = path.resolve(skill.filePath);
+      const relative = path.relative(SKILLS_ROOT, resolvedPath);
+      if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        findings.push({ severity: 'high', code: 'path_escape', message: 'Skill file is outside the managed skills directory.' });
+      }
+      const command = String(skill.metadata?.command || '');
+      if (command) {
+        const bare = command.replace(/\{[^{}]*\}/g, '');
+        if (SHELL_METACHAR_RE.test(bare)) {
+          findings.push({ severity: 'high', code: 'unsafe_command_template', message: 'Command template contains unsafe shell metacharacters.' });
+        }
+      }
+      const dependencies = Array.isArray(skill.metadata?.dependencies) ? skill.metadata.dependencies : [];
+      for (const dependency of dependencies) {
+        if (typeof dependency !== 'string' || !/^(?:@[\w.-]+\/)?[\w.-]+(?:@[\w.*^~<>=|-]+)?$/.test(dependency)) {
+          findings.push({ severity: 'medium', code: 'untrusted_dependency', message: 'Dependency metadata contains an unsupported package reference.' });
+        }
+      }
+      return {
+        name: skill.name,
+        enabled: skill.metadata?.enabled !== false,
+        autoCreated: skill.metadata?.auto_created === true,
+        findingCount: findings.length,
+        findings,
+      };
+    });
+  }
+}
+
+module.exports = {
+  CapabilityAuditService,
+};

package/server/services/tasks/adapters/index.js

@@ -3,6 +3,7 @@
 module.exports = [
   require('./schedule'),
   require('./manual'),
+  require('./webhook'),
   require('./gmail_message_received'),
   require('./outlook_email_received'),
   require('./slack_message_received'),

package/server/services/tasks/adapters/webhook.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = {
+  type: 'webhook',
+  label: 'Signed Webhook',
+  async validateConfig(config = {}) {
+    return {
+      sourceLabel: String(config.sourceLabel || config.source_label || '').trim() || null,
+    };
+  },
+  summarize(config = {}) {
+    return config.sourceLabel ? `Signed webhook from ${config.sourceLabel}` : 'Signed webhook';
+  },
+};

package/server/services/tasks/runtime.js

@@ -194,7 +194,7 @@ class TaskRuntime {
       label: adapter.label,
       providerKey: adapter.providerKey || null,
       appKey: adapter.appKey || null,
-      available: adapter.type === 'schedule' || adapter.type === 'manual'
+      available: ['schedule', 'manual', 'webhook'].includes(adapter.type)
         ? true
         : this._hasConnectedApp(userId, agentId, adapter.providerKey, adapter.appKey),
     }));

package/server/services/tasks/webhooks.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const crypto = require('crypto');
+const { v4: uuidv4 } = require('uuid');
+const db = require('../../db/database');
+const { encryptValue, decryptValue } = require('../integrations/secrets');
+
+const MAX_PAYLOAD_BYTES = 256 * 1024;
+const MAX_CLOCK_SKEW_MS = 5 * 60 * 1000;
+
+function safeEqual(left, right) {
+  const a = Buffer.from(String(left || ''), 'utf8');
+  const b = Buffer.from(String(right || ''), 'utf8');
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+class TaskWebhookService {
+  constructor(options = {}) {
+    this.taskRuntime = options.taskRuntime;
+  }
+
+  rotateSecret(userId, taskId) {
+    const task = this.taskRuntime.taskRepository.getTaskById(taskId, userId);
+    if (!task) throw new Error('Task not found.');
+    if (task.trigger_type !== 'webhook') throw new Error('Task does not use the webhook trigger.');
+    const secret = crypto.randomBytes(32).toString('base64url');
+    const fingerprint = crypto.createHash('sha256').update(secret).digest('hex').slice(0, 16);
+    db.prepare(
+      `INSERT INTO task_webhook_secrets (
+        task_id, user_id, secret_encrypted, secret_fingerprint
+      ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(task_id) DO UPDATE SET
+        secret_encrypted = excluded.secret_encrypted,
+        secret_fingerprint = excluded.secret_fingerprint,
+        rotated_at = datetime('now')`
+    ).run(taskId, userId, encryptValue(secret), fingerprint);
+    return { taskId, secret, fingerprint };
+  }
+
+  getConfiguration(userId, taskId) {
+    const task = this.taskRuntime.taskRepository.getTaskById(taskId, userId);
+    if (!task) throw new Error('Task not found.');
+    const row = db.prepare(
+      `SELECT secret_fingerprint, rotated_at, created_at
+       FROM task_webhook_secrets WHERE task_id = ? AND user_id = ?`
+    ).get(taskId, userId);
+    return {
+      taskId,
+      configured: Boolean(row),
+      fingerprint: row?.secret_fingerprint || null,
+      rotatedAt: row?.rotated_at || null,
+      createdAt: row?.created_at || null,
+    };
+  }
+
+  listDeliveries(userId, taskId, limit = 50) {
+    return db.prepare(
+      `SELECT id, request_id, payload_hash, status, response_json, created_at, completed_at
+       FROM task_webhook_deliveries
+       WHERE task_id = ? AND user_id = ?
+       ORDER BY created_at DESC LIMIT ?`
+    ).all(taskId, userId, Math.min(Math.max(Number(limit || 50), 1), 200)).map((row) => ({
+      id: row.id,
+      requestId: row.request_id,
+      payloadHash: row.payload_hash,
+      status: row.status,
+      response: (() => {
+        try { return JSON.parse(row.response_json || '{}'); } catch { return {}; }
+      })(),
+      createdAt: row.created_at,
+      completedAt: row.completed_at,
+    }));
+  }
+
+  async deliver(taskId, headers, rawBody, payload) {
+    if (Buffer.byteLength(rawBody || '', 'utf8') > MAX_PAYLOAD_BYTES) {
+      const error = new Error('Webhook payload exceeds 256 KiB.');
+      error.status = 413;
+      throw error;
+    }
+    const timestamp = Number(headers['x-neoagent-timestamp']);
+    const requestId = String(headers['x-neoagent-request-id'] || '').trim();
+    const supplied = String(headers['x-neoagent-signature'] || '').replace(/^sha256=/, '');
+    if (!requestId || !Number.isFinite(timestamp) || !supplied) {
+      const error = new Error('Missing webhook authentication headers.');
+      error.status = 401;
+      throw error;
+    }
+    if (Math.abs(Date.now() - timestamp) > MAX_CLOCK_SKEW_MS) {
+      const error = new Error('Webhook timestamp is outside the allowed window.');
+      error.status = 401;
+      throw error;
+    }
+    const secretRow = db.prepare(
+      `SELECT secrets.user_id, secrets.secret_encrypted, tasks.enabled, tasks.trigger_type
+       FROM task_webhook_secrets AS secrets
+       JOIN scheduled_tasks AS tasks ON tasks.id = secrets.task_id
+       WHERE secrets.task_id = ?`
+    ).get(taskId);
+    if (!secretRow || !secretRow.enabled || secretRow.trigger_type !== 'webhook') {
+      const error = new Error('Webhook task is unavailable.');
+      error.status = 404;
+      throw error;
+    }
+    const expected = crypto.createHmac('sha256', decryptValue(secretRow.secret_encrypted))
+      .update(`${timestamp}.${rawBody || ''}`)
+      .digest('hex');
+    if (!safeEqual(expected, supplied)) {
+      const error = new Error('Invalid webhook signature.');
+      error.status = 401;
+      throw error;
+    }
+    const deliveryId = uuidv4();
+    const payloadHash = crypto.createHash('sha256').update(rawBody || '').digest('hex');
+    try {
+      db.prepare(
+        `INSERT INTO task_webhook_deliveries (
+          id, task_id, user_id, request_id, payload_hash, status
+        ) VALUES (?, ?, ?, ?, ?, 'accepted')`
+      ).run(deliveryId, taskId, secretRow.user_id, requestId, payloadHash);
+    } catch (err) {
+      if (err.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+        const replayError = new Error('Webhook request ID was already used.');
+        replayError.status = 409;
+        throw replayError;
+      }
+      throw err;
+    }
+    const result = await this.taskRuntime.fireTaskFromTrigger(taskId, secretRow.user_id, {
+      fingerprint: requestId,
+      timestamp: new Date(timestamp).toISOString(),
+      context: { webhook: payload },
+    });
+    db.prepare(
+      `UPDATE task_webhook_deliveries
+       SET status = ?, response_json = ?, completed_at = datetime('now')
+       WHERE id = ?`
+    ).run(result?.error ? 'failed' : 'completed', JSON.stringify(result || {}), deliveryId);
+    return { deliveryId, accepted: !result?.error, result };
+  }
+}
+
+module.exports = {
+  TaskWebhookService,
+  MAX_PAYLOAD_BYTES,
+};