neoagent 2.3.1-beta.62 → 2.3.1-beta.64

package/flutter_app/lib/main_unified.dart

@@ -0,0 +1,388 @@
+part of 'main.dart';
+
+enum _ToolsPageTab { integrations, mcp, skills }
+
+enum _RunsPageTab { runs, logs }
+
+enum _SettingsWorkspaceSection { app, account, security }
+
+class ToolsPanel extends StatefulWidget {
+  const ToolsPanel({super.key, required this.controller});
+
+  final NeoAgentController controller;
+
+  @override
+  State<ToolsPanel> createState() => _ToolsPanelState();
+}
+
+class _ToolsPanelState extends State<ToolsPanel>
+    with SingleTickerProviderStateMixin {
+  late final TabController _tabController;
+
+  @override
+  void initState() {
+    super.initState();
+    _tabController = TabController(
+      length: _ToolsPageTab.values.length,
+      vsync: this,
+      initialIndex: _tabForSection(widget.controller.selectedSection).index,
+    );
+  }
+
+  @override
+  void didUpdateWidget(covariant ToolsPanel oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    final selectedSection = widget.controller.selectedSection;
+    if (selectedSection != oldWidget.controller.selectedSection &&
+        (selectedSection == AppSection.integrations ||
+            selectedSection == AppSection.mcp ||
+            selectedSection == AppSection.skills)) {
+      final targetIndex = _tabForSection(selectedSection).index;
+      if (_tabController.index != targetIndex) {
+        _tabController.index = targetIndex;
+      }
+    }
+  }
+
+  @override
+  void dispose() {
+    _tabController.dispose();
+    super.dispose();
+  }
+
+  _ToolsPageTab _tabForSection(AppSection section) {
+    switch (section) {
+      case AppSection.mcp:
+        return _ToolsPageTab.mcp;
+      case AppSection.skills:
+        return _ToolsPageTab.skills;
+      default:
+        return _ToolsPageTab.integrations;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final controller = widget.controller;
+    final visibleIntegrations = controller.officialIntegrations
+        .where(
+          (item) =>
+              item.env.configured ||
+              item.env.setupMode == 'user' ||
+              item.isConnected,
+        )
+        .length;
+    return Padding(
+      padding: _pagePadding(context),
+      child: Column(
+        children: <Widget>[
+          const _PageTitle(
+            title: 'Tools',
+            subtitle:
+                'Manage official integrations, MCP servers, and reusable skills in one place.',
+          ),
+          const SizedBox(height: 12),
+          Container(
+            decoration: BoxDecoration(
+              color: _bgSecondary,
+              borderRadius: BorderRadius.circular(14),
+              border: Border.all(color: _border),
+            ),
+            child: TabBar(
+              controller: _tabController,
+              dividerColor: Colors.transparent,
+              indicatorSize: TabBarIndicatorSize.tab,
+              labelStyle: const TextStyle(fontWeight: FontWeight.w700),
+              tabs: <Widget>[
+                Tab(text: 'Integrations ($visibleIntegrations)'),
+                Tab(text: 'MCP (${controller.mcpServers.length})'),
+                Tab(text: 'Skills (${controller.skills.length})'),
+              ],
+            ),
+          ),
+          const SizedBox(height: 12),
+          Expanded(
+            child: TabBarView(
+              controller: _tabController,
+              children: <Widget>[
+                IntegrationsPanel(controller: controller, embedded: true),
+                McpPanel(controller: controller, embedded: true),
+                SkillsPanel(controller: controller, embedded: true),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class RunsAndLogsPanel extends StatefulWidget {
+  const RunsAndLogsPanel({super.key, required this.controller});
+
+  final NeoAgentController controller;
+
+  @override
+  State<RunsAndLogsPanel> createState() => _RunsAndLogsPanelState();
+}
+
+class _RunsAndLogsPanelState extends State<RunsAndLogsPanel>
+    with SingleTickerProviderStateMixin {
+  late final TabController _tabController;
+
+  @override
+  void initState() {
+    super.initState();
+    _tabController = TabController(
+      length: _RunsPageTab.values.length,
+      vsync: this,
+      initialIndex: _tabForSection(widget.controller.selectedSection).index,
+    );
+  }
+
+  @override
+  void didUpdateWidget(covariant RunsAndLogsPanel oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    final selectedSection = widget.controller.selectedSection;
+    if (selectedSection != oldWidget.controller.selectedSection &&
+        (selectedSection == AppSection.runs ||
+            selectedSection == AppSection.logs)) {
+      final targetIndex = _tabForSection(selectedSection).index;
+      if (_tabController.index != targetIndex) {
+        _tabController.index = targetIndex;
+      }
+    }
+  }
+
+  @override
+  void dispose() {
+    _tabController.dispose();
+    super.dispose();
+  }
+
+  _RunsPageTab _tabForSection(AppSection section) {
+    switch (section) {
+      case AppSection.logs:
+        return _RunsPageTab.logs;
+      default:
+        return _RunsPageTab.runs;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final controller = widget.controller;
+    return Padding(
+      padding: _pagePadding(context),
+      child: Column(
+        children: <Widget>[
+          const _PageTitle(
+            title: 'Runs & Logs',
+            subtitle:
+                'Inspect execution history, failures, tool traces, and diagnostics from one workspace.',
+          ),
+          const SizedBox(height: 12),
+          Container(
+            decoration: BoxDecoration(
+              color: _bgSecondary,
+              borderRadius: BorderRadius.circular(14),
+              border: Border.all(color: _border),
+            ),
+            child: TabBar(
+              controller: _tabController,
+              dividerColor: Colors.transparent,
+              indicatorSize: TabBarIndicatorSize.tab,
+              labelStyle: const TextStyle(fontWeight: FontWeight.w700),
+              tabs: <Widget>[
+                Tab(text: 'Runs (${controller.recentRuns.length})'),
+                Tab(text: 'Logs (${controller.logs.length})'),
+              ],
+            ),
+          ),
+          const SizedBox(height: 12),
+          Expanded(
+            child: TabBarView(
+              controller: _tabController,
+              children: <Widget>[
+                RunsPanel(controller: controller, embedded: true),
+                LogsPanel(controller: controller, embedded: true),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class SettingsWorkspacePanel extends StatefulWidget {
+  const SettingsWorkspacePanel({super.key, required this.controller});
+
+  final NeoAgentController controller;
+
+  @override
+  State<SettingsWorkspacePanel> createState() => _SettingsWorkspacePanelState();
+}
+
+class _SettingsWorkspacePanelState extends State<SettingsWorkspacePanel> {
+  late _SettingsWorkspaceSection _selectedSection;
+
+  @override
+  void initState() {
+    super.initState();
+    _selectedSection =
+        widget.controller.selectedSection == AppSection.accountSettings
+        ? _SettingsWorkspaceSection.account
+        : _SettingsWorkspaceSection.app;
+  }
+
+  @override
+  void didUpdateWidget(covariant SettingsWorkspacePanel oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (widget.controller.selectedSection == AppSection.settings &&
+        _selectedSection != _SettingsWorkspaceSection.app) {
+      _selectedSection = _SettingsWorkspaceSection.app;
+    }
+    if (widget.controller.selectedSection == AppSection.accountSettings &&
+        _selectedSection == _SettingsWorkspaceSection.app) {
+      _selectedSection = _SettingsWorkspaceSection.account;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final compact = MediaQuery.sizeOf(context).width < 960;
+    return Padding(
+      padding: _pagePadding(context),
+      child: Column(
+        children: <Widget>[
+          const _PageTitle(
+            title: 'Settings',
+            subtitle:
+                'Workspace configuration and account security in one place.',
+          ),
+          const SizedBox(height: 12),
+          Expanded(
+            child: Card(
+              child: Padding(
+                padding: const EdgeInsets.all(20),
+                child: compact
+                    ? Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: <Widget>[
+                          _SettingsWorkspaceNav(
+                            selected: _selectedSection,
+                            compact: true,
+                            onSelected: _selectSection,
+                          ),
+                          const SizedBox(height: 16),
+                          Expanded(child: _buildContent()),
+                        ],
+                      )
+                    : Row(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: <Widget>[
+                          SizedBox(
+                            width: 220,
+                            child: _SettingsWorkspaceNav(
+                              selected: _selectedSection,
+                              compact: false,
+                              onSelected: _selectSection,
+                            ),
+                          ),
+                          const SizedBox(width: 24),
+                          Expanded(child: _buildContent()),
+                        ],
+                      ),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _selectSection(_SettingsWorkspaceSection section) {
+    setState(() => _selectedSection = section);
+    if (section == _SettingsWorkspaceSection.app) {
+      widget.controller.setSelectedSection(AppSection.settings);
+      return;
+    }
+    widget.controller.setSelectedSection(AppSection.accountSettings);
+  }
+
+  Widget _buildContent() {
+    switch (_selectedSection) {
+      case _SettingsWorkspaceSection.app:
+        return SettingsPanel(controller: widget.controller, embedded: true);
+      case _SettingsWorkspaceSection.account:
+        return AccountSettingsPanel(
+          controller: widget.controller,
+          embedded: true,
+          initialTab: AccountSettingsTab.account,
+        );
+      case _SettingsWorkspaceSection.security:
+        return AccountSettingsPanel(
+          controller: widget.controller,
+          embedded: true,
+          initialTab: AccountSettingsTab.security,
+        );
+    }
+  }
+}
+
+class _SettingsWorkspaceNav extends StatelessWidget {
+  const _SettingsWorkspaceNav({
+    required this.selected,
+    required this.compact,
+    required this.onSelected,
+  });
+
+  final _SettingsWorkspaceSection selected;
+  final bool compact;
+  final ValueChanged<_SettingsWorkspaceSection> onSelected;
+
+  @override
+  Widget build(BuildContext context) {
+    final items = <Widget>[
+      _navButton(
+        section: _SettingsWorkspaceSection.app,
+        icon: Icons.tune,
+        label: 'App Settings',
+      ),
+      _navButton(
+        section: _SettingsWorkspaceSection.account,
+        icon: Icons.person_outline,
+        label: 'Account',
+      ),
+      _navButton(
+        section: _SettingsWorkspaceSection.security,
+        icon: Icons.security_outlined,
+        label: 'Security',
+      ),
+    ];
+    return compact
+        ? Wrap(spacing: 8, runSpacing: 8, children: items)
+        : Column(
+            crossAxisAlignment: CrossAxisAlignment.stretch,
+            children: items,
+          );
+  }
+
+  Widget _navButton({
+    required _SettingsWorkspaceSection section,
+    required IconData icon,
+    required String label,
+  }) {
+    final button = _SidebarButton(
+      label: label,
+      icon: icon,
+      active: selected == section,
+      onTap: () => onSelected(section),
+    );
+    if (compact) {
+      return button;
+    }
+    return Padding(padding: const EdgeInsets.only(bottom: 8), child: button);
+  }
+}

package/flutter_app/lib/src/analytics_service.dart

@@ -0,0 +1,294 @@
+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/flutter_app/lib/src/backend_client.dart

@@ -463,6 +463,10 @@ class BackendClient {
     return getMap(baseUrl, '/api/version');
   }
 
+  Future<Map<String, dynamic>> fetchRuntimeConfig(String baseUrl) async {
+    return getMap(baseUrl, '/api/runtime/config', allowUnauthorized: true);
+  }
+
   Future<Map<String, dynamic>> fetchBrowserStatus(String baseUrl) async {
     return getMap(baseUrl, '/api/browser/status');
   }

package/flutter_app/macos/Flutter/GeneratedPluginRegistrant.swift

@@ -11,6 +11,7 @@ import desktop_audio_capture
 import flutter_secure_storage_macos
 import geolocator_apple
 import hotkey_manager_macos
+import mixpanel_flutter
 import mobile_scanner
 import package_info_plus
 import path_provider_foundation
@@ -30,6 +31,7 @@ func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   FlutterSecureStoragePlugin.register(with: registry.registrar(forPlugin: "FlutterSecureStoragePlugin"))
   GeolocatorPlugin.register(with: registry.registrar(forPlugin: "GeolocatorPlugin"))
   HotkeyManagerMacosPlugin.register(with: registry.registrar(forPlugin: "HotkeyManagerMacosPlugin"))
+  MixpanelFlutterPlugin.register(with: registry.registrar(forPlugin: "MixpanelFlutterPlugin"))
   MobileScannerPlugin.register(with: registry.registrar(forPlugin: "MobileScannerPlugin"))
   FPPPackageInfoPlusPlugin.register(with: registry.registrar(forPlugin: "FPPPackageInfoPlusPlugin"))
   PathProviderPlugin.register(with: registry.registrar(forPlugin: "PathProviderPlugin"))