neoagent 2.4.2-beta.4 → 2.4.2-beta.5

package/server/routes/admin.js

@@ -416,20 +416,69 @@ router.delete('/api/settings/apikey', requireAdminAuth, settingsLimiter, (req, r
 
 router.get('/api/analytics', requireAdminAuth, (req, res) => {
   const db = require('../db/database');
+  const range = Math.min(Math.max(parseInt(req.query.range) || 30, 1), 365);
   const now = new Date().toISOString();
   const dayAgo  = new Date(Date.now() - 86_400_000).toISOString();
   const weekAgo = new Date(Date.now() - 7 * 86_400_000).toISOString();
+  const rangeAgo = new Date(Date.now() - range * 86_400_000).toISOString();
   try {
+    const totalRunsRow  = db.prepare('SELECT COUNT(*) AS n, COALESCE(SUM(total_tokens),0) AS t FROM agent_runs').get();
+    const successRow    = db.prepare("SELECT COUNT(*) AS n FROM agent_runs WHERE status = 'completed'").get();
     const stats = {
-      totalUsers:    db.prepare('SELECT COUNT(*) AS n FROM users').get().n,
-      activeToday:   db.prepare('SELECT COUNT(*) AS n FROM users WHERE last_login > ?').get(dayAgo).n,
-      newThisWeek:   db.prepare('SELECT COUNT(*) AS n FROM users WHERE created_at > ?').get(weekAgo).n,
-      totalRuns:     db.prepare('SELECT COUNT(*) AS n FROM agent_runs').get().n,
-      runsToday:     db.prepare('SELECT COUNT(*) AS n FROM agent_runs WHERE created_at > ?').get(dayAgo).n,
-      totalTokens:   db.prepare('SELECT COALESCE(SUM(total_tokens),0) AS n FROM agent_runs').get().n,
-      activeSessions:db.prepare('SELECT COUNT(*) AS n FROM user_sessions WHERE revoked_at IS NULL AND expires_at > ?').get(now).n,
-      totalStorage:  db.prepare('SELECT COALESCE(SUM(byte_size),0) AS n FROM artifacts').get().n,
+      totalUsers:     db.prepare('SELECT COUNT(*) AS n FROM users').get().n,
+      activeToday:    db.prepare('SELECT COUNT(*) AS n FROM users WHERE last_login > ?').get(dayAgo).n,
+      newThisWeek:    db.prepare('SELECT COUNT(*) AS n FROM users WHERE created_at > ?').get(weekAgo).n,
+      totalRuns:      totalRunsRow.n,
+      runsToday:      db.prepare('SELECT COUNT(*) AS n FROM agent_runs WHERE created_at > ?').get(dayAgo).n,
+      runsThisWeek:   db.prepare('SELECT COUNT(*) AS n FROM agent_runs WHERE created_at > ?').get(weekAgo).n,
+      totalTokens:    totalRunsRow.t,
+      tokensToday:    db.prepare("SELECT COALESCE(SUM(total_tokens),0) AS n FROM agent_runs WHERE created_at > ?").get(dayAgo).n,
+      avgTokensPerRun: totalRunsRow.n > 0 ? Math.round(totalRunsRow.t / totalRunsRow.n) : 0,
+      successRate:    totalRunsRow.n > 0 ? Math.round((successRow.n / totalRunsRow.n) * 100) : 0,
+      activeSessions: db.prepare('SELECT COUNT(*) AS n FROM user_sessions WHERE revoked_at IS NULL AND expires_at > ?').get(now).n,
+      totalStorage:   db.prepare('SELECT COALESCE(SUM(byte_size),0) AS n FROM artifacts').get().n,
     };
+
+    // Time-series: runs + tokens per day for selected range
+    const runsByDay = db.prepare(`
+      SELECT date(created_at) AS date,
+             COUNT(*) AS runs,
+             COALESCE(SUM(total_tokens), 0) AS tokens
+      FROM agent_runs
+      WHERE created_at > ?
+      GROUP BY date(created_at)
+      ORDER BY date
+    `).all(rangeAgo);
+
+    // New users per day for selected range
+    const usersByDay = db.prepare(`
+      SELECT date(created_at) AS date, COUNT(*) AS newUsers
+      FROM users
+      WHERE created_at > ?
+      GROUP BY date(created_at)
+      ORDER BY date
+    `).all(rangeAgo);
+
+    // Model breakdown (top 10 by runs)
+    const modelBreakdown = db.prepare(`
+      SELECT COALESCE(model, 'unknown') AS model,
+             COUNT(*) AS runs,
+             COALESCE(SUM(total_tokens), 0) AS tokens
+      FROM agent_runs
+      WHERE created_at > ?
+      GROUP BY model
+      ORDER BY runs DESC
+      LIMIT 10
+    `).all(rangeAgo);
+
+    // Run status breakdown
+    const statusBreakdown = db.prepare(`
+      SELECT status, COUNT(*) AS count
+      FROM agent_runs
+      GROUP BY status
+      ORDER BY count DESC
+    `).all();
+
     const topUsers = db.prepare(`
       SELECT u.id, u.username, u.display_name,
              COALESCE(r.runs,    0) AS runs,
@@ -437,25 +486,25 @@ router.get('/api/analytics', requireAdminAuth, (req, res) => {
              COALESCE(a.storage, 0) AS storage
       FROM users u
       LEFT JOIN (
-        SELECT user_id,
-               COUNT(*)                   AS runs,
-               COALESCE(SUM(total_tokens),0) AS tokens
+        SELECT user_id, COUNT(*) AS runs, COALESCE(SUM(total_tokens),0) AS tokens
         FROM agent_runs GROUP BY user_id
       ) r ON r.user_id = u.id
       LEFT JOIN (
         SELECT user_id, COALESCE(SUM(byte_size),0) AS storage
         FROM artifacts GROUP BY user_id
       ) a ON a.user_id = u.id
-      ORDER BY runs DESC LIMIT 8
+      ORDER BY tokens DESC LIMIT 10
     `).all();
+
     const recentRuns = db.prepare(`
-      SELECT r.id, u.username, r.title, r.status, r.total_tokens,
+      SELECT r.id, u.username, r.title, r.status, r.model, r.total_tokens,
              r.created_at, r.completed_at
       FROM agent_runs r
       JOIN users u ON u.id = r.user_id
-      ORDER BY r.created_at DESC LIMIT 20
+      ORDER BY r.created_at DESC LIMIT 25
     `).all();
-    res.json({ stats, topUsers, recentRuns });
+
+    res.json({ stats, runsByDay, usersByDay, modelBreakdown, statusBreakdown, topUsers, recentRuns });
   } catch (err) {
     res.status(500).json({ error: String(err.message || err) });
   }
@@ -645,20 +694,20 @@ router.get('/api/models', requireAdminAuth, async (req, res) => {
   const { getSupportedModels } = require('../services/ai/models');
   try {
     const models = await getSupportedModels(null, null);
-    const enabledModelsStr = process.env.NEOAGENT_ENABLED_MODELS || '';
-    const enabledModelsList = enabledModelsStr ? enabledModelsStr.split(',').map(s => s.trim()).filter(s => s.length > 0) : [];
-    res.json({ models, enabledModels: enabledModelsList });
+    const disabledStr = process.env.NEOAGENT_DISABLED_MODELS || '';
+    const disabledModels = disabledStr ? disabledStr.split(',').map(s => s.trim()).filter(Boolean) : [];
+    res.json({ models, disabledModels });
   } catch (err) {
     res.status(500).json({ error: String(err.message || err) });
   }
 });
 
-router.put('/api/models/enabled', requireAdminAuth, express.json(), (req, res) => {
-  const { enabledModels } = req.body || {};
-  if (!Array.isArray(enabledModels)) return res.status(400).json({ error: 'enabledModels must be an array' });
-  const value = enabledModels.join(',');
-  upsertEnvValue(ENV_FILE, 'NEOAGENT_ENABLED_MODELS', value);
-  process.env.NEOAGENT_ENABLED_MODELS = value;
+router.put('/api/models/config', requireAdminAuth, express.json(), (req, res) => {
+  const { disabledModels } = req.body || {};
+  if (!Array.isArray(disabledModels)) return res.status(400).json({ error: 'disabledModels must be an array' });
+  const value = disabledModels.join(',');
+  upsertEnvValue(ENV_FILE, 'NEOAGENT_DISABLED_MODELS', value);
+  process.env.NEOAGENT_DISABLED_MODELS = value;
   res.json({ ok: true });
 });
 

package/server/routes/runtime.js

@@ -1,14 +1,11 @@
 'use strict';
 
 const express = require('express');
-const { getAnalyticsConfig } = require('../config/analytics');
 
 const router = express.Router();
 
 router.get('/config', (req, res) => {
-  res.json({
-    analytics: getAnalyticsConfig(),
-  });
+  res.json({});
 });
 
 module.exports = router;

package/server/services/ai/models.js

@@ -430,8 +430,8 @@ async function getSupportedModels(userId, agentId = null) {
         }
     }
 
-    const globalEnabledStr = process.env.NEOAGENT_ENABLED_MODELS || '';
-    const globalEnabledSet = globalEnabledStr ? new Set(globalEnabledStr.split(',').map(s => s.trim()).filter(Boolean)) : null;
+    const globalDisabledStr = process.env.NEOAGENT_DISABLED_MODELS || '';
+    const globalDisabledSet = globalDisabledStr ? new Set(globalDisabledStr.split(',').map(s => s.trim()).filter(Boolean)) : null;
 
     return all.map((model) => {
         const provider = providerById.get(model.provider);
@@ -440,9 +440,9 @@ async function getSupportedModels(userId, agentId = null) {
         const priceTier = model.provider === 'ollama'
             ? 'free'
             : (model.priceTier ?? classifyPriceTier(model.id));
-        
+
         let available = provider?.available !== false;
-        if (globalEnabledSet && !globalEnabledSet.has(model.id)) {
+        if (available && globalDisabledSet?.has(model.id)) {
             available = false;
         }
 

package/flutter_app/lib/src/analytics_service.dart

@@ -1,294 +0,0 @@
-import 'package:mixpanel_flutter/mixpanel_flutter.dart';
-
-class AppAnalytics {
-  Mixpanel? _mixpanel;
-  bool _initialized = false;
-  bool _enabled = false;
-  String? _currentToken;
-  bool _consentGranted = false;
-  final List<_QueuedEvent> _queue = <_QueuedEvent>[];
-
-  bool get enabled => _enabled && _consentGranted;
-  bool get consentGranted => _consentGranted;
-  bool get isConfigured => (_currentToken ?? '').isNotEmpty;
-
-  Future<void> initialize({
-    required String? token,
-    required bool consentGranted,
-  }) async {
-    final normalizedToken = token?.trim() ?? '';
-    final shouldEnable = normalizedToken.isNotEmpty;
-    if (_initialized &&
-        normalizedToken == _currentToken &&
-        shouldEnable == _enabled &&
-        consentGranted == _consentGranted) {
-      return;
-    }
-
-    _consentGranted = consentGranted;
-    _initialized = false;
-    _enabled = false;
-    _currentToken = normalizedToken.isEmpty ? null : normalizedToken;
-    _mixpanel = null;
-
-    if (!shouldEnable) {
-      _queue.clear();
-      _initialized = true;
-      return;
-    }
-
-    if (!consentGranted) {
-      _queue.clear();
-      _initialized = true;
-      return;
-    }
-
-    try {
-      _mixpanel = await Mixpanel.init(
-        normalizedToken,
-        trackAutomaticEvents: false,
-      );
-      _enabled = true;
-      _initialized = true;
-      await _flushQueue();
-    } catch (_) {
-      _queue.clear();
-      _mixpanel = null;
-      _enabled = false;
-      _initialized = true;
-    }
-  }
-
-  Future<void> setConsentGranted(bool consentGranted) async {
-    if (_consentGranted == consentGranted && _initialized) {
-      return;
-    }
-
-    _consentGranted = consentGranted;
-    if (!consentGranted) {
-      _mixpanel = null;
-      _enabled = false;
-      _initialized = true;
-      _queue.clear();
-      return;
-    }
-
-    await initialize(token: _currentToken, consentGranted: true);
-  }
-
-  Future<void> track(
-    String eventName, {
-    Map<String, Object?> properties = const <String, Object?>{},
-  }) async {
-    final event = _QueuedEvent(
-      eventName: eventName,
-      properties: _cleanProperties(properties),
-    );
-
-    if (!_initialized) {
-      _queue.add(event);
-      return;
-    }
-
-    if (!enabled || _mixpanel == null) {
-      return;
-    }
-
-    await _sendEvent(event);
-  }
-
-  Future<void> trackAppOpened({
-    required String appMode,
-    required String platform,
-    required String backendMode,
-    required String selectedSection,
-    required String deploymentProfile,
-    required bool authenticated,
-  }) {
-    return track(
-      'app_opened',
-      properties: <String, Object?>{
-        'app_mode': appMode,
-        'platform': platform,
-        'backend_mode': backendMode,
-        'selected_section': selectedSection,
-        'deployment_profile': deploymentProfile,
-        'authenticated': authenticated,
-      },
-    );
-  }
-
-  Future<void> trackBackendUrlSaved({
-    required String backendMode,
-  }) {
-    return track(
-      'backend_url_saved',
-      properties: <String, Object?>{
-        'backend_mode': backendMode,
-      },
-    );
-  }
-
-  Future<void> trackSectionChanged({
-    required String section,
-    required String previousSection,
-  }) {
-    return track(
-      'section_changed',
-      properties: <String, Object?>{
-        'section': section,
-        'previous_section': previousSection,
-      },
-    );
-  }
-
-  Future<void> trackChatMessageSent({
-    required int length,
-    required bool steeringLiveRun,
-  }) {
-    return track(
-      'chat_message_sent',
-      properties: <String, Object?>{
-        'length': length,
-        'steering_live_run': steeringLiveRun,
-      },
-    );
-  }
-
-  Future<void> trackRecordingStarted({
-    required String kind,
-  }) {
-    return track(
-      'recording_started',
-      properties: <String, Object?>{
-        'kind': kind,
-      },
-    );
-  }
-
-  Future<void> trackRecordingStopped({
-    required String kind,
-    required String stopReason,
-  }) {
-    return track(
-      'recording_stopped',
-      properties: <String, Object?>{
-        'kind': kind,
-        'stop_reason': stopReason,
-      },
-    );
-  }
-
-  Future<void> trackAppUpdateCheck({
-    required bool silent,
-  }) {
-    return track(
-      'app_update_check',
-      properties: <String, Object?>{
-        'silent': silent,
-      },
-    );
-  }
-
-  Future<void> trackTaskRunRequested({
-    required int taskId,
-  }) {
-    return track(
-      'task_run_requested',
-      properties: <String, Object?>{
-        'task_id': taskId,
-      },
-    );
-  }
-
-  Future<void> trackWidgetRefreshRequested({
-    required bool all,
-  }) {
-    return track(
-      'widget_refresh_requested',
-      properties: <String, Object?>{
-        'all': all,
-      },
-    );
-  }
-
-  Future<void> trackAppUpdateTriggered() {
-    return track('app_update_triggered');
-  }
-
-  Future<void> trackSignedIn({
-    required String authMethod,
-    required bool isRegistration,
-  }) {
-    return track(
-      'signed_in',
-      properties: <String, Object?>{
-        'auth_method': authMethod,
-        'is_registration': isRegistration,
-      },
-    );
-  }
-
-  Future<void> trackSignedOut() {
-    return track('signed_out');
-  }
-
-  Future<void> trackOnboardingDismissed() {
-    return track('onboarding_dismissed');
-  }
-
-  Future<void> dispose() async {
-    try {
-      await _flushQueue();
-    } catch (_) {}
-    _queue.clear();
-    _mixpanel = null;
-    _initialized = false;
-    _enabled = false;
-    _currentToken = null;
-    _consentGranted = false;
-  }
-
-  Future<void> _flushQueue() async {
-    if (!enabled || _mixpanel == null || _queue.isEmpty) {
-      return;
-    }
-
-    final pending = List<_QueuedEvent>.from(_queue);
-    _queue.clear();
-    for (final event in pending) {
-      await _sendEvent(event);
-    }
-  }
-
-  Future<void> _sendEvent(_QueuedEvent event) async {
-    final mixpanel = _mixpanel;
-    if (mixpanel == null) {
-      return;
-    }
-
-    try {
-      await mixpanel.track(event.eventName, properties: event.properties);
-    } catch (_) {}
-  }
-
-  Map<String, Object?> _cleanProperties(Map<String, Object?> properties) {
-    final cleaned = <String, Object?>{};
-    for (final entry in properties.entries) {
-      final value = entry.value;
-      if (value == null) continue;
-      cleaned[entry.key] = value;
-    }
-    return cleaned;
-  }
-}
-
-class _QueuedEvent {
-  const _QueuedEvent({
-    required this.eventName,
-    required this.properties,
-  });
-
-  final String eventName;
-  final Map<String, Object?> properties;
-}

package/server/config/analytics.js

@@ -1,30 +0,0 @@
-'use strict';
-
-const DEFAULT_MIXPANEL_TOKEN = '4a47ae6a05cf39a8faf0438a1200dde6';
-
-function normalizeToken(value) {
-  return String(value || '').trim();
-}
-
-function resolveMixpanelToken() {
-  if (Object.prototype.hasOwnProperty.call(process.env, 'NEOAGENT_MIXPANEL_TOKEN')) {
-    return normalizeToken(process.env.NEOAGENT_MIXPANEL_TOKEN);
-  }
-  return normalizeToken(DEFAULT_MIXPANEL_TOKEN);
-}
-
-function getAnalyticsConfig() {
-  const mixpanelToken = resolveMixpanelToken();
-  return {
-    mixpanel: {
-      enabled: mixpanelToken.length > 0,
-      token: mixpanelToken || null,
-    },
-  };
-}
-
-module.exports = {
-  DEFAULT_MIXPANEL_TOKEN,
-  getAnalyticsConfig,
-  resolveMixpanelToken,
-};