neoagent 2.4.4-beta.0 → 2.4.4-beta.11

package/server/routes/account.js

@@ -38,6 +38,7 @@ const {
   approveChallenge,
   resolveChallengeForApproval,
 } = require('../services/account/qr_login');
+const { getRateLimitSnapshot } = require('../services/ai/rate_limits');
 
 const accountLimiter = rateLimit({
   windowMs: 15 * 60 * 1000,
@@ -112,29 +113,7 @@ router.get('/', (req, res) => {
 
 router.get('/usage', (req, res) => {
   try {
-    const userId = req.session.userId;
-    const userLimits = db.prepare('SELECT rate_limit_4h, rate_limit_weekly FROM users WHERE id = ?').get(userId);
-    const h4Tokens = db.prepare("SELECT COALESCE(SUM(total_tokens), 0) as t FROM agent_runs WHERE user_id = ? AND created_at > datetime('now', '-4 hours')").get(userId).t;
-    const weeklyTokens = db.prepare("SELECT COALESCE(SUM(total_tokens), 0) as t FROM agent_runs WHERE user_id = ? AND created_at > datetime('now', '-7 days')").get(userId).t;
-
-    const globalLimit4h = process.env.NEOAGENT_RATE_LIMIT_4H ? parseInt(process.env.NEOAGENT_RATE_LIMIT_4H, 10) : null;
-    const globalLimitWeekly = process.env.NEOAGENT_RATE_LIMIT_WEEKLY ? parseInt(process.env.NEOAGENT_RATE_LIMIT_WEEKLY, 10) : null;
-
-    const custom4h = userLimits?.rate_limit_4h ?? null;
-    const customWeekly = userLimits?.rate_limit_weekly ?? null;
-
-    res.json({
-      limits: {
-        fourHour: custom4h ?? globalLimit4h,
-        weekly: customWeekly ?? globalLimitWeekly,
-        fourHourIsCustom: custom4h !== null,
-        weeklyIsCustom: customWeekly !== null,
-      },
-      usage: {
-        fourHour: h4Tokens,
-        weekly: weeklyTokens,
-      }
-    });
+    res.json(getRateLimitSnapshot(req.session.userId));
   } catch (err) {
     sendRouteError(res, err);
   }

package/server/routes/admin.js

@@ -18,6 +18,7 @@ const {
 const { APP_DIR, ENV_FILE, upsertEnvValue } = require('../../runtime/paths');
 const { isManagedDeployment } = require('../utils/deployment');
 const rateLimit = require('express-rate-limit');
+const { configuredDefaultLimits } = require('../services/ai/rate_limits');
 
 const router = express.Router();
 const ADMIN_DIR = path.join(__dirname, '..', 'admin');
@@ -324,6 +325,20 @@ const sqlLimiter = rateLimit({
   message: { error: 'Too many SQL queries, slow down' },
 });
 
+router.get('/api/config/email', requireAdminAuth, (req, res) => {
+  const { getAdminEmailSettings } = require('../services/account/service_email_settings');
+  res.json(getAdminEmailSettings());
+});
+
+router.put('/api/config/email', requireAdminAuth, settingsLimiter, express.json(), (req, res) => {
+  try {
+    const { updateAdminEmailSettings } = require('../services/account/service_email_settings');
+    res.json({ ok: true, ...updateAdminEmailSettings(req.body) });
+  } catch (err) {
+    res.status(err.statusCode || 500).json({ error: err.message });
+  }
+});
+
 // --- Access settings (signup toggle + API key) ---
 
 router.get('/api/settings', requireAdminAuth, (req, res) => {
@@ -670,9 +685,10 @@ router.put('/api/providers', requireAdminAuth, express.json(), (req, res) => {
 // --- Global default rate limits ---
 
 router.get('/api/config/rate-limits', requireAdminAuth, (req, res) => {
+  const defaults = configuredDefaultLimits();
   res.json({
-    rate_limit_4h: process.env.NEOAGENT_RATE_LIMIT_4H ? parseInt(process.env.NEOAGENT_RATE_LIMIT_4H, 10) : null,
-    rate_limit_weekly: process.env.NEOAGENT_RATE_LIMIT_WEEKLY ? parseInt(process.env.NEOAGENT_RATE_LIMIT_WEEKLY, 10) : null,
+    rate_limit_4h: defaults.fourHour,
+    rate_limit_weekly: defaults.weekly,
   });
 });
 

package/server/routes/agents.js

@@ -130,7 +130,11 @@ router.post('/', async (req, res) => {
 
     res.json(result);
   } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
+    res.status(err?.statusCode || err?.status || 500).json({
+      error: sanitizeError(err),
+      code: err?.code,
+      rateLimit: err?.rateLimit,
+    });
   }
 });
 

package/server/routes/memory.js

@@ -28,6 +28,14 @@ const transferImportLimiter = rateLimit({
   legacyHeaders: false,
 });
 
+const memorySearchLimiter = rateLimit({
+  windowMs: 1 * 60 * 1000,
+  max: 60,
+  message: { error: 'Too many memory search requests, try again later' },
+  standardHeaders: true,
+  legacyHeaders: false,
+});
+
 const MAX_TRANSFER_TEXT_BYTES = 60 * 1024;
 
 function normalizeMemoryIds(value) {
@@ -378,20 +386,49 @@ router.post('/memories/bulk-archive', (req, res) => {
 });
 
 // Semantic recall (search)
-router.post('/memories/recall', async (req, res) => {
+router.post('/memories/recall', memorySearchLimiter, async (req, res) => {
   const mm = req.app.locals.memoryManager;
   const userId = req.session.userId;
   const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
   const { query, limit = 8 } = req.body;
   if (!query) return res.status(400).json({ error: 'query is required' });
+
+  let parsedLimit = Number.parseInt(limit, 10);
+  if (!Number.isFinite(parsedLimit) || Number.isNaN(parsedLimit)) {
+    return res.status(400).json({ error: 'limit must be an integer between 1 and 100' });
+  }
+  parsedLimit = Math.max(1, Math.min(100, parsedLimit));
+
   try {
-    const results = await mm.recallMemory(userId, query, parseInt(limit), { agentId });
+    const results = await mm.recallMemory(userId, query, parsedLimit, { agentId });
     res.json(results);
   } catch (err) {
     res.status(500).json({ error: sanitizeError(err) });
   }
 });
 
+// Semantic recall inspection (UI debug)
+router.post('/memories/inspect', memorySearchLimiter, async (req, res) => {
+  const mm = req.app.locals.memoryManager;
+  const userId = req.session.userId;
+  const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
+  const { query, limit = 20 } = req.body;
+  if (!query) return res.status(400).json({ error: 'query is required' });
+
+  let parsedLimit = Number.parseInt(limit, 10);
+  if (!Number.isFinite(parsedLimit) || Number.isNaN(parsedLimit)) {
+    return res.status(400).json({ error: 'limit must be an integer between 1 and 100' });
+  }
+  parsedLimit = Math.max(1, Math.min(100, parsedLimit));
+
+  try {
+    const results = await mm.recallMemory(userId, query, parsedLimit, { agentId });
+    res.json({ results });
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Core Memory
 // ─────────────────────────────────────────────────────────────────────────────
@@ -457,7 +494,7 @@ router.post('/transfer-import', transferImportLimiter, async (req, res) => {
     if (applyCoreMemory && parsed.coreEntries) {
       for (const [key, value] of Object.entries(parsed.coreEntries)) {
         if (!key || key === 'active_context') continue;
-        mm.updateCore(userId, key, value, { agentId, confirmed: true });
+        mm.updateCore(userId, key, value, { agentId });
         coreUpdatedCount += 1;
       }
     }
@@ -489,7 +526,7 @@ router.put('/core/:key', (req, res) => {
   if (req.params.key === 'active_context') {
     return res.status(400).json({ error: 'active_context is no longer a supported core memory key' });
   }
-  mm.updateCore(userId, req.params.key, value, { agentId, confirmed: true });
+  mm.updateCore(userId, req.params.key, value, { agentId });
   res.json({ success: true });
 });
 

package/server/routes/security.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const express = require('express');
+const router = express.Router();
+const { requireAuth } = require('../middleware/auth');
+const db = require('../db/database');
+const { TOOL_CATEGORIES, getCategoryForTool } = require('../services/security/tool_categories');
+
+router.use(requireAuth);
+
+// ── Security mode ─────────────────────────────────────────────────────────────
+
+// GET /api/security/mode — current global security mode
+router.get('/mode', (req, res) => {
+  const mode = req.app.locals.toolPolicyService.getSecurityMode(req.session.userId);
+  res.json({ mode });
+});
+
+// PUT /api/security/mode — update global security mode
+router.put('/mode', (req, res) => {
+  const { mode } = req.body;
+  if (!mode) return res.status(400).json({ error: 'mode is required' });
+  try {
+    req.app.locals.toolPolicyService.setSecurityMode(req.session.userId, mode);
+    res.json({ ok: true, mode });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// ── Per-category policies ─────────────────────────────────────────────────────
+
+// GET /api/security/policies — all category policies + current mode
+router.get('/policies', (req, res) => {
+  const { toolPolicyService } = req.app.locals;
+  const policies = toolPolicyService.getPolicies(req.session.userId);
+  const mode = toolPolicyService.getSecurityMode(req.session.userId);
+  res.json({ policies, mode, categories: Object.keys(TOOL_CATEGORIES) });
+});
+
+// PUT /api/security/policies — update a single category policy
+router.put('/policies', (req, res) => {
+  const { category, policy } = req.body;
+  if (!category || !policy) {
+    return res.status(400).json({ error: 'category and policy are required' });
+  }
+  try {
+    req.app.locals.toolPolicyService.setPolicy(req.session.userId, category, policy);
+    res.json({ ok: true, category, policy });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// ── Approval decisions ────────────────────────────────────────────────────────
+
+// POST /api/security/approvals/:approvalId — resolve a pending approval
+router.post('/approvals/:approvalId', (req, res) => {
+  const { approvalId } = req.params;
+  const { decision, scope, runId, toolName, toolArgs } = req.body;
+
+  if (!decision || !['approved', 'denied'].includes(decision)) {
+    return res.status(400).json({ error: 'decision must be approved or denied' });
+  }
+  const normalizedScope = ['once', 'session', 'always'].includes(scope) ? scope : 'once';
+
+  // 'always' scope: also persist the policy so this category is allowed going forward
+  if (decision === 'approved' && normalizedScope === 'always' && toolName) {
+    try {
+      const category = getCategoryForTool(toolName, toolArgs ?? {});
+      if (category) {
+        req.app.locals.toolPolicyService.setPolicy(req.session.userId, category, 'allow');
+      }
+    } catch {}
+  }
+
+  const { approvalGateService } = req.app.locals;
+  const resolved = approvalGateService.resolve(
+    approvalId,
+    req.session.userId,
+    runId || null,
+    toolName || null,
+    toolArgs || {},
+    decision,
+    normalizedScope,
+  );
+  if (!resolved) {
+    return res.status(404).json({ error: 'Approval not found or already resolved' });
+  }
+  res.json({ ok: true, approvalId, decision, scope: normalizedScope });
+});
+
+// ── Audit log ─────────────────────────────────────────────────────────────────
+
+// GET /api/security/approval-log — paginated audit log
+router.get('/approval-log', (req, res) => {
+  const limit = Math.min(Number(req.query.limit) || 50, 200);
+  const offset = Number(req.query.offset) || 0;
+  const rows = db.prepare(`
+    SELECT id, run_id, tool_name, tool_args_json, decision, scope, decided_at
+    FROM tool_approval_log
+    WHERE user_id = ?
+    ORDER BY decided_at DESC
+    LIMIT ? OFFSET ?
+  `).all(req.session.userId, limit, offset);
+  const total = db.prepare(
+    'SELECT COUNT(*) as count FROM tool_approval_log WHERE user_id = ?'
+  ).get(req.session.userId)?.count ?? 0;
+  res.json({ log: rows, total, limit, offset });
+});
+
+module.exports = router;

package/server/services/account/service_email_settings.js

@@ -0,0 +1,167 @@
+'use strict';
+
+const { ENV_FILE, upsertEnvValue } = require('../../../runtime/paths');
+
+const STRING_FIELDS = Object.freeze({
+  from: 'NEOAGENT_EMAIL_FROM',
+  smtpHost: 'NEOAGENT_EMAIL_SMTP_HOST',
+  smtpUser: 'NEOAGENT_EMAIL_SMTP_USER',
+  replyTo: 'NEOAGENT_EMAIL_REPLY_TO',
+  brandName: 'NEOAGENT_EMAIL_BRAND_NAME',
+  supportUrl: 'NEOAGENT_EMAIL_SUPPORT_URL',
+  publicUrl: 'NEOAGENT_EMAIL_PUBLIC_URL',
+});
+
+const BOOLEAN_FIELDS = Object.freeze({
+  smtpSecure: ['NEOAGENT_EMAIL_SMTP_SECURE', false],
+  smtpRequireTls: ['NEOAGENT_EMAIL_SMTP_REQUIRE_TLS', true],
+  smtpRejectUnauthorized: ['NEOAGENT_EMAIL_SMTP_REJECT_UNAUTHORIZED', true],
+  requireSignupConfirmation: ['NEOAGENT_EMAIL_REQUIRE_SIGNUP_CONFIRMATION', true],
+  requireEmailChangeConfirmation: ['NEOAGENT_EMAIL_REQUIRE_EMAIL_CHANGE_CONFIRMATION', true],
+  notifyUnusualLogin: ['NEOAGENT_EMAIL_NOTIFY_UNUSUAL_LOGIN', true],
+  notifyAccountChanges: ['NEOAGENT_EMAIL_NOTIFY_ACCOUNT_CHANGES', true],
+});
+
+function envString(env, key) {
+  return String(env[key] || '').trim();
+}
+
+function envBoolean(env, key, defaultValue) {
+  const value = envString(env, key).toLowerCase();
+  if (!value) return defaultValue;
+  return ['1', 'true', 'yes', 'on'].includes(value);
+}
+
+function envPositiveInteger(env, key, defaultValue) {
+  const value = Number(envString(env, key));
+  return Number.isInteger(value) && value > 0 ? value : defaultValue;
+}
+
+function cleanSingleLine(value, label) {
+  const cleaned = String(value ?? '').trim();
+  if (/[\r\n]/.test(cleaned)) {
+    const error = new Error(`${label} must be a single line.`);
+    error.statusCode = 400;
+    throw error;
+  }
+  return cleaned;
+}
+
+function requireBoolean(value, label) {
+  if (typeof value !== 'boolean') {
+    const error = new Error(`${label} must be true or false.`);
+    error.statusCode = 400;
+    throw error;
+  }
+  return value;
+}
+
+function requireInteger(value, label, { min, max }) {
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < min || number > max) {
+    const error = new Error(`${label} must be an integer from ${min} to ${max}.`);
+    error.statusCode = 400;
+    throw error;
+  }
+  return number;
+}
+
+function requireHttpUrl(value, label) {
+  const cleaned = cleanSingleLine(value, label);
+  if (!cleaned) return '';
+  try {
+    const url = new URL(cleaned);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error('invalid protocol');
+  } catch {
+    const error = new Error(`${label} must be an HTTP or HTTPS URL.`);
+    error.statusCode = 400;
+    throw error;
+  }
+  return cleaned.replace(/\/$/, '');
+}
+
+function encodeEnvValue(value) {
+  return JSON.stringify(String(value));
+}
+
+function persistValue(envFile, env, key, value) {
+  upsertEnvValue(envFile, key, encodeEnvValue(value));
+  if (value === '') {
+    delete env[key];
+  } else {
+    env[key] = String(value);
+  }
+}
+
+function getAdminEmailSettings({ env = process.env } = {}) {
+  const smtpPort = envPositiveInteger(env, 'NEOAGENT_EMAIL_SMTP_PORT', 587);
+  const settings = {
+    smtpPort,
+    tokenTtlHours: envPositiveInteger(env, 'NEOAGENT_EMAIL_TOKEN_TTL_HOURS', 24),
+    smtpPasswordConfigured: Boolean(envString(env, 'NEOAGENT_EMAIL_SMTP_PASS')),
+  };
+
+  for (const [name, key] of Object.entries(STRING_FIELDS)) {
+    settings[name] = envString(env, key);
+  }
+  for (const [name, [key, defaultValue]] of Object.entries(BOOLEAN_FIELDS)) {
+    let effectiveDefault = defaultValue;
+    if (name === 'smtpSecure') effectiveDefault = smtpPort === 465;
+    if (name === 'smtpRequireTls') effectiveDefault = !settings.smtpSecure;
+    settings[name] = envBoolean(env, key, effectiveDefault);
+  }
+
+  const missing = [];
+  if (!settings.from) missing.push('Sender address');
+  if (!settings.smtpHost) missing.push('SMTP host');
+
+  return {
+    configured: missing.length === 0,
+    missing,
+    settings,
+  };
+}
+
+function updateAdminEmailSettings(body, { env = process.env, envFile = ENV_FILE } = {}) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    const error = new Error('Email settings must be an object.');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const values = {};
+  for (const name of Object.keys(STRING_FIELDS)) {
+    values[name] = name === 'supportUrl' || name === 'publicUrl'
+      ? requireHttpUrl(body[name], name === 'supportUrl' ? 'Support URL' : 'Public URL')
+      : cleanSingleLine(body[name], name);
+  }
+
+  values.smtpPort = requireInteger(body.smtpPort, 'SMTP port', { min: 1, max: 65535 });
+  values.tokenTtlHours = requireInteger(body.tokenTtlHours, 'Token lifetime', { min: 1, max: 8760 });
+
+  for (const name of Object.keys(BOOLEAN_FIELDS)) {
+    values[name] = requireBoolean(body[name], name);
+  }
+
+  const smtpPassword = cleanSingleLine(body.smtpPassword, 'SMTP password');
+  const clearSmtpPassword = body.clearSmtpPassword === true;
+
+  for (const [name, key] of Object.entries(STRING_FIELDS)) {
+    persistValue(envFile, env, key, values[name]);
+  }
+  persistValue(envFile, env, 'NEOAGENT_EMAIL_SMTP_PORT', values.smtpPort);
+  persistValue(envFile, env, 'NEOAGENT_EMAIL_TOKEN_TTL_HOURS', values.tokenTtlHours);
+  for (const [name, [key]] of Object.entries(BOOLEAN_FIELDS)) {
+    persistValue(envFile, env, key, values[name]);
+  }
+  if (smtpPassword || clearSmtpPassword) {
+    persistValue(envFile, env, 'NEOAGENT_EMAIL_SMTP_PASS', clearSmtpPassword ? '' : smtpPassword);
+  }
+
+  return getAdminEmailSettings({ env });
+}
+
+module.exports = {
+  getAdminEmailSettings,
+  updateAdminEmailSettings,
+};