neoagent 2.3.1-beta.2 → 2.3.1-beta.21

package/flutter_app/lib/src/desktop_screen_capture.dart

@@ -0,0 +1,21 @@
+import 'desktop_screen_capture_stub.dart'
+    if (dart.library.io) 'desktop_screen_capture_io.dart';
+
+DesktopScreenCapture createDesktopScreenCapture() =>
+    createPlatformDesktopScreenCapture();
+
+class DesktopScreenCaptureResult {
+  const DesktopScreenCaptureResult({
+    required this.bytes,
+    required this.mimeType,
+  });
+
+  final List<int> bytes;
+  final String mimeType;
+}
+
+abstract class DesktopScreenCapture {
+  bool get isSupported;
+
+  Future<DesktopScreenCaptureResult?> captureCurrentScreen();
+}

package/flutter_app/lib/src/desktop_screen_capture_io.dart

@@ -0,0 +1,142 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+
+import 'desktop_native_bridge.dart';
+import 'desktop_screen_capture.dart';
+
+DesktopScreenCapture createPlatformDesktopScreenCapture() =>
+    _DesktopScreenCaptureIo();
+
+class _DesktopScreenCaptureIo implements DesktopScreenCapture {
+  final DesktopNativeBridge _nativeBridge = DesktopNativeBridge();
+
+  @override
+  bool get isSupported =>
+      !kIsWeb &&
+      (defaultTargetPlatform == TargetPlatform.macOS ||
+          defaultTargetPlatform == TargetPlatform.windows ||
+          defaultTargetPlatform == TargetPlatform.linux);
+
+  @override
+  Future<DesktopScreenCaptureResult?> captureCurrentScreen() async {
+    if (!isSupported) {
+      return null;
+    }
+
+    switch (defaultTargetPlatform) {
+      case TargetPlatform.macOS:
+        return _captureMacos();
+      case TargetPlatform.windows:
+        return _captureWindows();
+      case TargetPlatform.linux:
+        return _captureLinux();
+      case TargetPlatform.android:
+      case TargetPlatform.iOS:
+      case TargetPlatform.fuchsia:
+        return null;
+    }
+  }
+
+  Future<DesktopScreenCaptureResult?> _captureMacos() async {
+    final result = await _nativeBridge.captureFrame();
+    final bytes = result['bytes'];
+    final mimeType = result['mimeType']?.toString() ?? 'image/png';
+    if (bytes is! Uint8List || bytes.isEmpty) {
+      return null;
+    }
+    return DesktopScreenCaptureResult(bytes: bytes, mimeType: mimeType);
+  }
+
+  Future<DesktopScreenCaptureResult?> _captureWindows() async {
+    final result = await _nativeBridge.captureFrame();
+    final bytes = result['bytes'];
+    final mimeType = result['mimeType']?.toString() ?? 'image/png';
+    if (bytes is! Uint8List || bytes.isEmpty) {
+      return null;
+    }
+    return DesktopScreenCaptureResult(bytes: bytes, mimeType: mimeType);
+  }
+
+  Future<DesktopScreenCaptureResult?> _captureLinux() async {
+    final attempts =
+        <
+          ({
+            String command,
+            List<String> args,
+            String extension,
+            String mimeType,
+          })
+        >[
+          (
+            command: 'grim',
+            args: <String>[],
+            extension: 'png',
+            mimeType: 'image/png',
+          ),
+          (
+            command: 'gnome-screenshot',
+            args: <String>['-f'],
+            extension: 'png',
+            mimeType: 'image/png',
+          ),
+          (
+            command: 'spectacle',
+            args: <String>['-b', '-n', '-o'],
+            extension: 'png',
+            mimeType: 'image/png',
+          ),
+        ];
+
+    Object? lastError;
+    for (final attempt in attempts) {
+      final file = await _temporaryFile(attempt.extension);
+      try {
+        final result = await Process.run(attempt.command, <String>[
+          ...attempt.args,
+          file.path,
+        ]);
+        if (result.exitCode == 0 && await file.exists()) {
+          return DesktopScreenCaptureResult(
+            bytes: await file.readAsBytes(),
+            mimeType: attempt.mimeType,
+          );
+        }
+        lastError = ProcessException(
+          attempt.command,
+          <String>[...attempt.args, file.path],
+          '${result.stderr}',
+          result.exitCode,
+        );
+      } on ProcessException catch (error) {
+        lastError = error;
+      } finally {
+        await _deleteIfExists(file);
+      }
+    }
+
+    if (lastError != null) {
+      throw lastError;
+    }
+    return null;
+  }
+
+  Future<File> _temporaryFile(String extension) async {
+    final directory = await Directory.systemTemp.createTemp(
+      'neoagent-assistant-screen-',
+    );
+    return File('${directory.path}/capture.$extension');
+  }
+
+  Future<void> _deleteIfExists(File file) async {
+    try {
+      if (await file.exists()) {
+        await file.delete();
+      }
+      final parent = file.parent;
+      if (await parent.exists()) {
+        await parent.delete();
+      }
+    } catch (_) {}
+  }
+}

package/flutter_app/lib/src/desktop_screen_capture_stub.dart

@@ -0,0 +1,12 @@
+import 'desktop_screen_capture.dart';
+
+DesktopScreenCapture createPlatformDesktopScreenCapture() =>
+    _UnsupportedDesktopScreenCapture();
+
+class _UnsupportedDesktopScreenCapture implements DesktopScreenCapture {
+  @override
+  bool get isSupported => false;
+
+  @override
+  Future<DesktopScreenCaptureResult?> captureCurrentScreen() async => null;
+}

package/flutter_app/lib/src/diagnostics_logger.dart

@@ -0,0 +1,119 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+
+@immutable
+class AppDiagnosticEntry {
+  const AppDiagnosticEntry({
+    required this.sequence,
+    required this.timestamp,
+    required this.area,
+    required this.event,
+    this.data = const <String, Object?>{},
+    this.error,
+    this.stackTrace,
+  });
+
+  final int sequence;
+  final DateTime timestamp;
+  final String area;
+  final String event;
+  final Map<String, Object?> data;
+  final String? error;
+  final String? stackTrace;
+}
+
+class AppDiagnostics {
+  AppDiagnostics._();
+
+  static bool enabled = const bool.fromEnvironment(
+    'NEOAGENT_VERBOSE_LOGS',
+    defaultValue: true,
+  );
+
+  static int _sequence = 0;
+  static const int _maxRetainedEntries = 400;
+  static final StreamController<AppDiagnosticEntry> _controller =
+      StreamController<AppDiagnosticEntry>.broadcast(sync: true);
+  static final List<AppDiagnosticEntry> _entries = <AppDiagnosticEntry>[];
+
+  static Stream<AppDiagnosticEntry> get stream => _controller.stream;
+
+  static List<AppDiagnosticEntry> get recentEntries =>
+      List<AppDiagnosticEntry>.unmodifiable(_entries);
+
+  static void log(
+    String area,
+    String event, {
+    Map<String, Object?> data = const <String, Object?>{},
+    Object? error,
+    StackTrace? stackTrace,
+  }) {
+    if (!enabled) {
+      return;
+    }
+
+    final seq = ++_sequence;
+    final timestamp = DateTime.now();
+    final now = timestamp.toIso8601String();
+    final normalizedData = data.isEmpty
+        ? const <String, Object?>{}
+        : _normalizeMap(data);
+    final normalized = <String, Object?>{
+      'ts': now,
+      'area': area,
+      'event': event,
+      if (normalizedData.isNotEmpty) 'data': normalizedData,
+      if (error != null) 'error': error.toString(),
+    };
+
+    debugPrint('[NeoDiag][$seq] ${jsonEncode(normalized)}');
+    if (stackTrace != null) {
+      debugPrint('[NeoDiag][$seq][stack] $stackTrace');
+    }
+
+    final entry = AppDiagnosticEntry(
+      sequence: seq,
+      timestamp: timestamp,
+      area: area,
+      event: event,
+      data: normalizedData,
+      error: error?.toString(),
+      stackTrace: stackTrace?.toString(),
+    );
+    _entries.add(entry);
+    if (_entries.length > _maxRetainedEntries) {
+      _entries.removeRange(0, _entries.length - _maxRetainedEntries);
+    }
+    if (!_controller.isClosed) {
+      _controller.add(entry);
+    }
+  }
+
+  static Map<String, Object?> _normalizeMap(Map<String, Object?> input) {
+    final output = <String, Object?>{};
+    input.forEach((key, value) {
+      output[key] = _normalizeValue(value);
+    });
+    return output;
+  }
+
+  static Object? _normalizeValue(Object? value) {
+    if (value == null ||
+        value is num ||
+        value is bool ||
+        value is String ||
+        value is Map<String, Object?> ||
+        value is List<Object?>) {
+      return value;
+    }
+    if (value is DateTime) {
+      return value.toIso8601String();
+    }
+    if (value is Duration) {
+      return value.inMilliseconds;
+    }
+    return value.toString();
+  }
+}

package/flutter_app/lib/src/health_bridge.dart

@@ -0,0 +1,136 @@
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+class HealthBridge {
+  static const MethodChannel _channel = MethodChannel('neoagent/health');
+
+  Future<HealthBridgeStatus> getStatus() async {
+    if (!_isAndroid) {
+      return const HealthBridgeStatus(
+        available: false,
+        permissionsGranted: false,
+        message: 'Health sync is available on Android only.',
+      );
+    }
+
+    final result = await _channel.invokeMapMethod<String, dynamic>('status');
+    if (result == null) {
+      return const HealthBridgeStatus(
+        available: false,
+        permissionsGranted: false,
+        message: 'Health status is unavailable.',
+      );
+    }
+
+    return HealthBridgeStatus(
+      available: result['available'] == true,
+      permissionsGranted: result['permissionsGranted'] == true,
+      message: result['message']?.toString(),
+      grantedPermissions: _stringListFromDynamic(result['grantedPermissions']),
+      requiredPermissions: _stringListFromDynamic(
+        result['requiredPermissions'],
+      ),
+    );
+  }
+
+  Future<HealthBridgeStatus> requestPermissions() async {
+    if (!_isAndroid) {
+      return getStatus();
+    }
+    await _channel.invokeMethod('requestPermissions');
+    return getStatus();
+  }
+
+  Future<Map<String, dynamic>> collectBatch({
+    required DateTime windowStart,
+    required DateTime windowEnd,
+  }) async {
+    if (!_isAndroid) {
+      throw const HealthBridgeException(
+        'Health sync is available on Android only.',
+      );
+    }
+    final raw = await _channel
+        .invokeMethod<String>('collectBatch', <String, dynamic>{
+          'windowStart': windowStart.toUtc().toIso8601String(),
+          'windowEnd': windowEnd.toUtc().toIso8601String(),
+        });
+    if (raw == null || raw.isEmpty) {
+      throw const HealthBridgeException('No health data payload returned.');
+    }
+    return jsonDecode(raw) as Map<String, dynamic>;
+  }
+
+  Future<void> configureBackgroundSync({
+    required bool enabled,
+    required String backendUrl,
+    required String sessionCookie,
+  }) async {
+    if (!_isAndroid) {
+      return;
+    }
+    await _channel.invokeMethod('configureBackgroundSync', <String, dynamic>{
+      'enabled': enabled,
+      'backendUrl': backendUrl,
+      'sessionCookie': sessionCookie,
+    });
+  }
+
+  bool get _isAndroid =>
+      !kIsWeb && defaultTargetPlatform == TargetPlatform.android;
+}
+
+class HealthBridgeStatus {
+  const HealthBridgeStatus({
+    required this.available,
+    required this.permissionsGranted,
+    this.message,
+    this.grantedPermissions = const <String>[],
+    this.requiredPermissions = const <String>[],
+  });
+
+  final bool available;
+  final bool permissionsGranted;
+  final String? message;
+  final List<String> grantedPermissions;
+  final List<String> requiredPermissions;
+}
+
+class HealthBridgeException implements Exception {
+  const HealthBridgeException(this.message);
+
+  final String message;
+
+  @override
+  String toString() => message;
+}
+
+List<String> _stringListFromDynamic(dynamic value) {
+  if (value is List) {
+    return value
+        .map((item) => item?.toString() ?? '')
+        .where((item) => item.isNotEmpty)
+        .toList();
+  }
+  if (value is Map) {
+    for (final key in const <String>[
+      'items',
+      'data',
+      'results',
+      'rows',
+      'values',
+      'list',
+    ]) {
+      final nested = value[key];
+      if (nested is List) {
+        return nested
+            .map((item) => item?.toString() ?? '')
+            .where((item) => item.isNotEmpty)
+            .toList();
+      }
+    }
+  }
+  return const <String>[];
+}

package/flutter_app/lib/src/live_voice_capture.dart

@@ -0,0 +1,85 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:record/record.dart';
+
+class LiveVoiceCapture {
+  LiveVoiceCapture() : _recorder = AudioRecorder();
+
+  final AudioRecorder _recorder;
+  StreamSubscription<Uint8List>? _subscription;
+  StreamSubscription<RecordState>? _stateSubscription;
+  bool _stopping = false;
+
+  Future<void> start({
+    required void Function(Uint8List chunk) onChunk,
+    void Function(Object error, StackTrace stackTrace)? onError,
+    VoidCallback? onStoppedUnexpectedly,
+    int sampleRate = 16000,
+    int channels = 1,
+  }) async {
+    await stop();
+
+    final hasPermission = await _recorder.hasPermission();
+    if (!hasPermission) {
+      throw StateError('Microphone permission is required for live voice.');
+    }
+
+    _stopping = false;
+    _stateSubscription = _recorder.onStateChanged().listen(
+      (state) {
+        if (_stopping) {
+          return;
+        }
+        if (state == RecordState.stop) {
+          onStoppedUnexpectedly?.call();
+        }
+      },
+      onError: (Object error, StackTrace stackTrace) {
+        if (_stopping) {
+          return;
+        }
+        onError?.call(error, stackTrace);
+      },
+    );
+
+    final stream = await _recorder.startStream(
+      RecordConfig(
+        encoder: AudioEncoder.pcm16bits,
+        sampleRate: sampleRate,
+        numChannels: channels,
+      ),
+    );
+
+    _subscription = stream.listen(
+      onChunk,
+      onError: (Object error, StackTrace stackTrace) {
+        if (_stopping) {
+          return;
+        }
+        onError?.call(error, stackTrace);
+      },
+      onDone: () {
+        if (_stopping) {
+          return;
+        }
+        onStoppedUnexpectedly?.call();
+      },
+      cancelOnError: false,
+    );
+  }
+
+  Future<void> stop() async {
+    _stopping = true;
+    await _subscription?.cancel();
+    _subscription = null;
+    await _stateSubscription?.cancel();
+    _stateSubscription = null;
+    await _recorder.stop();
+  }
+
+  Future<void> dispose() async {
+    await stop();
+    await _recorder.dispose();
+  }
+}

package/flutter_app/lib/src/messaging_access_summary.dart

@@ -0,0 +1,46 @@
+import 'package:flutter/material.dart';
+
+class MessagingAccessSummaryCard extends StatelessWidget {
+  const MessagingAccessSummaryCard({
+    super.key,
+    required this.accent,
+    required this.summary,
+    required this.hint,
+  });
+
+  final Color accent;
+  final String summary;
+  final String hint;
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      width: double.infinity,
+      padding: const EdgeInsets.all(16),
+      decoration: BoxDecoration(
+        gradient: LinearGradient(
+          colors: <Color>[
+            accent.withValues(alpha: 0.18),
+            Theme.of(context).dialogTheme.backgroundColor ??
+                Theme.of(context).colorScheme.surface,
+          ],
+          begin: Alignment.topLeft,
+          end: Alignment.bottomRight,
+        ),
+        borderRadius: BorderRadius.circular(18),
+        border: Border.all(color: accent.withValues(alpha: 0.28)),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: <Widget>[
+          Text(
+            summary,
+            style: const TextStyle(fontWeight: FontWeight.w700),
+          ),
+          const SizedBox(height: 6),
+          Text(hint),
+        ],
+      ),
+    );
+  }
+}

package/flutter_app/lib/src/network/app_http_client.dart

@@ -0,0 +1,53 @@
+import 'dart:typed_data';
+
+abstract class AppHttpClient {
+  Future<HttpResponseData> get(Uri uri, {Map<String, String>? headers});
+
+  Future<HttpResponseData> post(
+    Uri uri, {
+    Map<String, String>? headers,
+    Object? body,
+  });
+
+  Future<HttpResponseData> postMultipart(
+    Uri uri, {
+    Map<String, String>? headers,
+    required String fieldName,
+    required String filename,
+    required Uint8List bytes,
+  });
+
+  Future<HttpResponseData> put(
+    Uri uri, {
+    Map<String, String>? headers,
+    Object? body,
+  });
+
+  Future<HttpResponseData> delete(
+    Uri uri, {
+    Map<String, String>? headers,
+    Object? body,
+  });
+
+  Future<void> close();
+
+  void clearSession();
+
+  void restoreSession(String? sessionCookie);
+
+  String? get sessionCookie;
+}
+
+class HttpResponseData {
+  const HttpResponseData({
+    required this.statusCode,
+    required this.body,
+    required this.bodyBytes,
+    required this.headers,
+  });
+
+  final int statusCode;
+  final String body;
+  final Uint8List bodyBytes;
+  final Map<String, String> headers;
+}

package/flutter_app/lib/src/network/app_http_client_factory.dart

@@ -0,0 +1,6 @@
+import 'app_http_client.dart';
+import 'app_http_client_stub.dart'
+    if (dart.library.html) 'app_http_client_web.dart'
+    if (dart.library.io) 'app_http_client_io.dart';
+
+AppHttpClient createAppHttpClient() => createPlatformHttpClient();