neoagent 2.3.1-beta.0 → 2.3.1-beta.100

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/android_apk_drop_zone.dart

@@ -0,0 +1,32 @@
+import 'dart:typed_data';
+
+import 'package:flutter/widgets.dart';
+
+import 'android_apk_drop_zone_stub.dart'
+    if (dart.library.html) 'android_apk_drop_zone_web.dart';
+
+typedef AndroidApkInstallCallback =
+    Future<void> Function({required String filename, required Uint8List bytes});
+
+class AndroidApkDropZone extends StatelessWidget {
+  const AndroidApkDropZone({
+    super.key,
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final AndroidApkInstallCallback onInstall;
+
+  @override
+  Widget build(BuildContext context) {
+    return buildAndroidApkDropZone(
+      context,
+      enabled: enabled,
+      busy: busy,
+      onInstall: onInstall,
+    );
+  }
+}

package/flutter_app/lib/src/android_apk_drop_zone_stub.dart

@@ -0,0 +1,16 @@
+import 'dart:typed_data';
+
+import 'package:flutter/widgets.dart';
+
+Widget buildAndroidApkDropZone(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return const SizedBox.shrink();
+}

package/flutter_app/lib/src/android_apk_drop_zone_web.dart

@@ -0,0 +1,348 @@
+// ignore_for_file: avoid_web_libraries_in_flutter, deprecated_member_use
+
+import 'dart:async';
+import 'dart:html' as html;
+import 'dart:typed_data';
+import 'dart:ui_web' as ui_web;
+
+import 'package:flutter/material.dart';
+
+int _androidApkDropZoneViewId = 0;
+const Set<String> _supportedAndroidInstallExtensions = <String>{
+  '.apk',
+  '.apks',
+};
+
+Widget buildAndroidApkDropZone(
+  BuildContext context, {
+  required bool enabled,
+  required bool busy,
+  required Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall,
+}) {
+  return _AndroidApkDropZoneWeb(
+    enabled: enabled,
+    busy: busy,
+    onInstall: onInstall,
+  );
+}
+
+class _AndroidApkDropZoneWeb extends StatefulWidget {
+  const _AndroidApkDropZoneWeb({
+    required this.enabled,
+    required this.busy,
+    required this.onInstall,
+  });
+
+  final bool enabled;
+  final bool busy;
+  final Future<void> Function({
+    required String filename,
+    required Uint8List bytes,
+  })
+  onInstall;
+
+  @override
+  State<_AndroidApkDropZoneWeb> createState() => _AndroidApkDropZoneWebState();
+}
+
+class _AndroidApkDropZoneWebState extends State<_AndroidApkDropZoneWeb> {
+  late final String _viewType;
+  late final html.DivElement _dropElement;
+  late final html.FileUploadInputElement _fileInput;
+  final List<StreamSubscription<dynamic>> _subscriptions =
+      <StreamSubscription<dynamic>>[];
+  bool _dragActive = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _viewType = 'neoagent-android-apk-drop-zone-${_androidApkDropZoneViewId++}';
+    _dropElement = html.DivElement()
+      ..setAttribute('role', 'button')
+      ..setAttribute(
+        'aria-label',
+        'Drop an APK or APK bundle here to install it',
+      )
+      ..tabIndex = 0
+      ..style.width = '100%'
+      ..style.height = '100%'
+      ..style.display = 'block'
+      ..style.background = 'rgba(0, 0, 0, 0.001)'
+      ..style.cursor = 'pointer';
+    _fileInput = html.FileUploadInputElement()
+      ..accept = '.apk,.apks'
+      ..multiple = false
+      ..style.display = 'none';
+    _dropElement.append(_fileInput);
+
+    _subscriptions.addAll(<StreamSubscription<dynamic>>[
+      _dropElement.onClick.listen((_) => _openPicker()),
+      _dropElement.onKeyDown.listen((event) {
+        if (event.key == 'Enter' || event.key == ' ') {
+          event.preventDefault();
+          _openPicker();
+        }
+      }),
+      _dropElement.onDragEnter.listen((event) {
+        event.preventDefault();
+        if (!_dragActive && mounted) {
+          setState(() => _dragActive = true);
+        }
+      }),
+      _dropElement.onDragOver.listen((event) {
+        event.preventDefault();
+        event.dataTransfer.dropEffect = 'copy';
+        if (!_dragActive && mounted) {
+          setState(() => _dragActive = true);
+        }
+      }),
+      _dropElement.onDragLeave.listen((event) {
+        event.preventDefault();
+        if (_dragActive && mounted) {
+          setState(() => _dragActive = false);
+        }
+      }),
+      _dropElement.onDrop.listen((event) {
+        event.preventDefault();
+        if (_dragActive && mounted) {
+          setState(() => _dragActive = false);
+        }
+        final files = event.dataTransfer.files;
+        if (files == null || files.isEmpty) {
+          return;
+        }
+        unawaited(_handleFile(files.first));
+      }),
+      _fileInput.onChange.listen((_) {
+        final files = _fileInput.files;
+        if (files == null || files.isEmpty) {
+          return;
+        }
+        unawaited(_handleFile(files.first));
+      }),
+    ]);
+
+    ui_web.platformViewRegistry.registerViewFactory(_viewType, (int _) {
+      return _dropElement;
+    });
+  }
+
+  @override
+  void dispose() {
+    for (final subscription in _subscriptions) {
+      subscription.cancel();
+    }
+    _dropElement.remove();
+    super.dispose();
+  }
+
+  void _openPicker() {
+    if (!widget.enabled || widget.busy) {
+      return;
+    }
+    _fileInput.value = '';
+    _fileInput.click();
+  }
+
+  Future<void> _handleFile(html.File file) async {
+    if (!widget.enabled || widget.busy) {
+      return;
+    }
+    if (!_isSupportedInstallFile(file.name)) {
+      _showError('Only .apk or .apks files can be installed.');
+      return;
+    }
+    try {
+      final bytes = await _readFileBytes(file);
+      if (!mounted) {
+        return;
+      }
+      await widget.onInstall(filename: file.name, bytes: bytes);
+    } catch (error) {
+      _showError(error.toString().replaceFirst('Exception: ', ''));
+    }
+  }
+
+  Future<Uint8List> _readFileBytes(html.File file) {
+    final completer = Completer<Uint8List>();
+    final reader = html.FileReader();
+    reader.onLoad.listen((_) {
+      final result = reader.result;
+      if (result is ByteBuffer) {
+        completer.complete(Uint8List.view(result));
+        return;
+      }
+      if (result is Uint8List) {
+        completer.complete(result);
+        return;
+      }
+      if (!completer.isCompleted) {
+        completer.completeError(
+          StateError('Could not read the Android app package.'),
+        );
+      }
+    });
+    reader.onError.listen((_) {
+      if (!completer.isCompleted) {
+        completer.completeError(
+          reader.error ?? StateError('Could not read the Android app package.'),
+        );
+      }
+    });
+    reader.readAsArrayBuffer(file);
+    return completer.future;
+  }
+
+  void _showError(String message) {
+    if (!mounted) {
+      return;
+    }
+    final messenger = ScaffoldMessenger.maybeOf(context);
+    if (messenger == null) {
+      return;
+    }
+    messenger.showSnackBar(SnackBar(content: Text(message)));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+    final cardColor = theme.cardTheme.color ?? colorScheme.surface;
+    final onSurface = colorScheme.onSurface;
+    final outline = colorScheme.outlineVariant;
+    final primary = colorScheme.primary;
+    final activeBorderColor = _dragActive ? primary : outline;
+    final background = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.14 : 0.10,
+          )
+        : widget.enabled
+        ? cardColor
+        : colorScheme.surfaceContainerHighest.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.84 : 0.92,
+          );
+    final iconBackground = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.18 : 0.14,
+          )
+        : colorScheme.surfaceContainerHighest.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.72 : 0.92,
+          );
+    final titleColor = onSurface;
+    final subtitleColor = colorScheme.onSurfaceVariant;
+    final dropZoneBorderColor = _dragActive ? primary : outline;
+    final dropZoneBackground = _dragActive
+        ? primary.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.10 : 0.08,
+          )
+        : colorScheme.surface.withValues(
+            alpha: theme.brightness == Brightness.dark ? 0.18 : 0.72,
+          );
+    final subtitle = widget.busy
+        ? 'Installing app package on the phone...'
+        : widget.enabled
+        ? 'Drag and drop a .apk or .apks file here, or click to browse.'
+        : 'Start the Android phone first, then drop a .apk or .apks file here.';
+
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(14),
+      decoration: BoxDecoration(
+        color: background,
+        borderRadius: BorderRadius.circular(18),
+        border: Border.all(color: activeBorderColor),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Row(
+            children: <Widget>[
+              Container(
+                width: 38,
+                height: 38,
+                decoration: BoxDecoration(
+                  color: iconBackground,
+                  borderRadius: BorderRadius.circular(12),
+                ),
+                child: Icon(
+                  Icons.install_mobile_outlined,
+                  color: _dragActive ? primary : titleColor,
+                ),
+              ),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: <Widget>[
+                    Text(
+                      'Install APK / Bundle',
+                      style: theme.textTheme.titleMedium?.copyWith(
+                        color: titleColor,
+                        fontWeight: FontWeight.w700,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      subtitle,
+                      style: theme.textTheme.bodyMedium?.copyWith(
+                        color: subtitleColor,
+                        height: 1.4,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+          const SizedBox(height: 12),
+          SizedBox(
+            height: 92,
+            child: Stack(
+              children: <Widget>[
+                Positioned.fill(
+                  child: DecoratedBox(
+                    decoration: BoxDecoration(
+                      borderRadius: BorderRadius.circular(14),
+                      border: Border.all(color: dropZoneBorderColor),
+                      color: dropZoneBackground,
+                    ),
+                    child: Center(
+                      child: Text(
+                        widget.busy
+                            ? 'Installing...'
+                            : _dragActive
+                            ? 'Release to install this package'
+                            : 'Drop APK or .apks Here',
+                        style: theme.textTheme.titleSmall?.copyWith(
+                          color: titleColor,
+                          fontWeight: FontWeight.w700,
+                          letterSpacing: 0.2,
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+                Positioned.fill(
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(14),
+                    child: HtmlElementView(viewType: _viewType),
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+bool _isSupportedInstallFile(String filename) {
+  final normalized = filename.toLowerCase();
+  return _supportedAndroidInstallExtensions.any(normalized.endsWith);
+}

package/flutter_app/lib/src/android_app_installer.dart

@@ -0,0 +1,22 @@
+import 'android_app_installer_stub.dart'
+    if (dart.library.io) 'android_app_installer_io.dart';
+
+AndroidAppInstaller createAndroidAppInstaller() =>
+    createPlatformAndroidAppInstaller();
+
+abstract class AndroidAppInstaller {
+  bool get supported;
+
+  Future<AndroidAppInstallResult> installApkFromUrl({
+    required String downloadUrl,
+    required String fileName,
+    Map<String, String> headers = const <String, String>{},
+  });
+}
+
+class AndroidAppInstallResult {
+  const AndroidAppInstallResult({required this.launched, this.error});
+
+  final bool launched;
+  final String? error;
+}