feat: add native debug viewer in advanced tab (#177)

* feat: add logging package

* feat: implement debug viewer and log capture functionality

* refactor: streamline log capture and debug viewer functionality

* refactor: simplify log display by removing filter options and test log generation

* style: adjust margin for log display area in debug viewer

* fix: reduce log refresh interval to 100ms for improved responsiveness

* style: adjust border radius in OptionContainer and remove unnecessary spacing in AdvancedTab

* chore: run `dart format .`

* fix: update font to use packaged DM Mono

* fix: improve formattedTimestamp method to handle shorter timestamps

* fix: conditionally print log messages in debug mode

* revert: move docs change to separate commit

* fix: refactor DebugViewer layout and wrap in OptionContainer

* fix: optimize log refresh logic in DebugViewer for better performance

* fix: enhance log handling in LogCapture to prevent duplicates and improve caching

* fix: improve log management in LogCapture to handle duplicates and enforce log limits

* fix: adjust log formatting in KeyEventService for improved readability

* chore: run `dart format .`

Author: conventoangelo

lib/app.dart

@@ -474,6 +474,17 @@ class _MainAppState extends ConsumerState<MainApp>
         return null;
       }
 
+      if (call.method == 'receiveLog') {
+        // Receive logs from other windows for log capture
+        try {
+          final logData = Map<String, dynamic>.from(call.arguments as Map);
+          LogCapture().addReceivedLog(logData);
+        } catch (_) {
+          // Ignore malformed log data
+        }
+        return null;
+      }
+
       await _methodCallHandler.handleMethodCall(
         call,
         ref,

lib/main.dart

@@ -9,6 +9,7 @@ import 'package:hotkey_manager/hotkey_manager.dart';
 import 'app.dart';
 import 'screens/preferences_screen.dart';
 import 'utils/window_controller_extension.dart';
+import 'utils/logger.dart';
 
 // Window type definitions
 enum WindowType {
@@ -26,6 +27,9 @@ enum WindowType {
 Future<void> main(List<String> args) async {
   WidgetsFlutterBinding.ensureInitialized();
 
+  // Initialize log capture early to catch all logs
+  LogCapture();
+
   // Get the current window controller
   final windowController = await WindowController.fromCurrentEngine();
 

lib/screens/preferences_screen.dart

@@ -24,6 +24,7 @@ import 'package:overkeys/widgets/tabs/hotkeys_tab.dart';
 import 'package:overkeys/widgets/tabs/learn_tab.dart';
 import 'package:overkeys/widgets/tabs/advanced_tab.dart';
 import 'package:overkeys/widgets/tabs/about_tab.dart';
+import 'package:overkeys/utils/logger.dart';
 
 class PreferencesScreen extends ConsumerStatefulWidget {
   const PreferencesScreen({super.key, required this.windowController});
@@ -112,6 +113,17 @@ class _PreferencesScreenState extends ConsumerState<PreferencesScreen>
       if (call.method == 'requestFocus') {
         await windowManager.focus();
       }
+
+      if (call.method == 'receiveLog' && mounted) {
+        // Receive logs from other windows (like main window)
+        try {
+          final logData = Map<String, dynamic>.from(call.arguments as Map);
+          LogCapture().addReceivedLog(logData);
+        } catch (_) {
+          // Ignore malformed log data
+        }
+      }
+
       return null;
     });
   }

lib/services/key_event_service.dart

@@ -81,7 +81,7 @@ class KeyEventService {
       // Display "Space" in logs for better readability instead of blank
       final displayKey = key == ' ' ? 'Space' : key;
       _log.debug(
-          'Key: ${displayKey.padRight(10)}\tKeyCode: ${keyCode.toString().padRight(5)}\tPressed: ${isPressed.toString().padRight(5)}\tShift: $isShiftDown');
+          'Key: ${displayKey.padRight(10)}\tKeyCode: ${keyCode.toString().padRight(5)}\tPressed: ${isPressed.toString().padRight(7)}\tShift: $isShiftDown');
 
       keyboardNotifier.updateKeyPressState(key, isPressed);
 

lib/utils/logger.dart

@@ -1,42 +1,244 @@
 import 'package:flutter/foundation.dart';
+import 'package:logging/logging.dart';
+import 'package:desktop_multi_window/desktop_multi_window.dart';
 
-/// Simple print-based logger with timestamps and log levels
-class SimplePrintLogger {
-  final String name;
+/// Log entry representing a single log record
+class LogEntry {
+  final DateTime timestamp;
+  final String loggerName;
+  final Level level;
+  final String message;
+  final Object? error;
+  final StackTrace? stackTrace;
 
-  SimplePrintLogger(this.name);
+  LogEntry({
+    required this.timestamp,
+    required this.loggerName,
+    required this.level,
+    required this.message,
+    this.error,
+    this.stackTrace,
+  });
 
-  String _timestamp() => DateTime.now().toString().substring(11, 23);
+  String get formattedTimestamp {
+    final str = timestamp.toString();
+    if (str.length >= 23) {
+      return str.substring(11, 23);
+    }
+    return str.length > 11 ? str.substring(11) : str;
+  }
 
-  void debug(String message) {
-    if (kDebugMode) {
-      print('[${_timestamp()}] [$name] $message');
+  String get levelEmoji {
+    if (level == Level.INFO) return 'ℹ️ ';
+    if (level == Level.WARNING) return '🚧 ';
+    if (level == Level.SEVERE) return '❌ ';
+    return '';
+  }
+
+  String get formattedMessage {
+    StringBuffer buffer = StringBuffer();
+    buffer.write('[$formattedTimestamp] [$loggerName] $levelEmoji$message');
+
+    if (error != null) {
+      buffer.write('\n[$formattedTimestamp] [$loggerName] $levelEmoji');
+      buffer.write('Error: $error');
     }
+
+    if (stackTrace != null) {
+      buffer.write('\n[$formattedTimestamp] [$loggerName] $levelEmoji');
+      buffer.write('StackTrace: $stackTrace');
+    }
+
+    return buffer.toString();
   }
+}
 
-  void info(String message) {
-    if (kDebugMode) {
-      print('[${_timestamp()}] [$name] ℹ️ $message');
+/// Singleton class to capture and store logs
+class LogCapture {
+  static final LogCapture _instance = LogCapture._internal();
+  factory LogCapture() => _instance;
+
+  final List<LogEntry> _logs = [];
+  final List<LogEntry> _receivedLogs =
+      []; // For logs received from other windows
+  static const int _maxLogs =
+      1000; // Keep last 1000 combined logs across both buffers
+
+  // Cache for combined logs
+  List<LogEntry>? _cachedCombinedLogs;
+  bool _isCacheValid = false;
+
+  LogCapture._internal() {
+    Logger.root.level = kDebugMode ? Level.ALL : Level.INFO;
+    Logger.root.onRecord.listen(_handleLogRecord);
+  }
+
+  void _trimLogsToLimit() {
+    while (_logs.length + _receivedLogs.length > _maxLogs) {
+      // Remove the oldest entry from either buffer
+      if (_logs.isEmpty) {
+        _receivedLogs.removeAt(0);
+      } else if (_receivedLogs.isEmpty) {
+        _logs.removeAt(0);
+      } else {
+        // Both have entries, remove from the one with the older timestamp
+        if (_logs.first.timestamp.isBefore(_receivedLogs.first.timestamp)) {
+          _logs.removeAt(0);
+        } else {
+          _receivedLogs.removeAt(0);
+        }
+      }
     }
   }
 
-  void warning(String message, {Object? error, StackTrace? stackTrace}) {
+  void _handleLogRecord(LogRecord record) {
+    final entry = LogEntry(
+      timestamp: record.time,
+      loggerName: record.loggerName,
+      level: record.level,
+      message: record.message,
+      error: record.error,
+      stackTrace: record.stackTrace,
+    );
+
+    _logs.add(entry);
+    _trimLogsToLimit();
+    _isCacheValid = false;
+
+    // Print to console
     if (kDebugMode) {
-      print('[${_timestamp()}] [$name] 🚧 $message');
-      if (error != null) print('[${_timestamp()}] [$name] 🚧 Error: $error');
-      if (stackTrace != null) {
-        print('[${_timestamp()}] [$name] 🚧 StackTrace: $stackTrace');
+      print(entry.formattedMessage);
+    }
+
+    // Broadcast to other windows for cross-isolate log viewing
+    _broadcastLog(entry);
+  }
+
+  void _broadcastLog(LogEntry entry) async {
+    try {
+      final logMap = {
+        'timestamp': entry.timestamp.toIso8601String(),
+        'loggerName': entry.loggerName,
+        'level': entry.level.value,
+        'message': entry.message,
+        'error': entry.error?.toString(),
+        'stackTrace': entry.stackTrace?.toString(),
+      };
+
+      final controllers = await WindowController.getAll();
+      for (final controller in controllers) {
+        controller.invokeMethod('receiveLog', logMap).catchError((_) => null);
       }
+    } catch (_) {
+      // Silently ignore broadcast errors
     }
   }
 
-  void error(String message, {Object? error, StackTrace? stackTrace}) {
-    if (kDebugMode) {
-      print('[${_timestamp()}] [$name] ❌ $message');
-      if (error != null) print('[${_timestamp()}] [$name] ❌ Error: $error');
-      if (stackTrace != null) {
-        print('[${_timestamp()}] [$name] ❌ StackTrace: $stackTrace');
+  void addReceivedLog(Map<String, dynamic> logData) {
+    try {
+      // Validate required fields
+      final timestamp = logData['timestamp'] as String?;
+      final loggerName = logData['loggerName'] as String?;
+      final levelValue = logData['level'] as int?;
+      final message = logData['message'] as String?;
+
+      if (timestamp == null ||
+          loggerName == null ||
+          levelValue == null ||
+          message == null) {
+        return;
       }
+
+      final parsedTimestamp = DateTime.parse(timestamp);
+      final level = Level.LEVELS.firstWhere(
+        (l) => l.value == levelValue,
+        orElse: () => Level.INFO,
+      );
+
+      // Check if this log already exists in _logs or _receivedLogs to avoid duplicates
+      // This happens when a window broadcasts to all windows including itself
+      // or when the same remote log is received multiple times
+      final isDuplicate = _logs.any((log) =>
+              log.timestamp == parsedTimestamp &&
+              log.loggerName == loggerName &&
+              log.level == level &&
+              log.message == message) ||
+          _receivedLogs.any((log) =>
+              log.timestamp == parsedTimestamp &&
+              log.loggerName == loggerName &&
+              log.level == level &&
+              log.message == message);
+
+      if (isDuplicate) {
+        return; // Skip adding duplicate from broadcast
+      }
+
+      final entry = LogEntry(
+        timestamp: parsedTimestamp,
+        loggerName: loggerName,
+        level: level,
+        message: message,
+        error: logData['error'],
+        stackTrace:
+            logData['stackTrace'] != null && logData['stackTrace'] != 'null'
+                ? StackTrace.fromString(logData['stackTrace'])
+                : null,
+      );
+
+      _receivedLogs.add(entry);
+      _trimLogsToLimit();
+      _isCacheValid = false;
+    } catch (_) {
+      // Silently ignore malformed log data
     }
   }
+
+  List<LogEntry> get logs {
+    if (_isCacheValid && _cachedCombinedLogs != null) {
+      return _cachedCombinedLogs!;
+    }
+
+    // Combine and sort logs from both sources
+    final combined = [..._logs, ..._receivedLogs];
+    combined.sort((a, b) => a.timestamp.compareTo(b.timestamp));
+    _cachedCombinedLogs = List.unmodifiable(combined);
+    _isCacheValid = true;
+    return _cachedCombinedLogs!;
+  }
+
+  int get logCount => _logs.length + _receivedLogs.length;
+
+  void clear() {
+    _logs.clear();
+    _receivedLogs.clear();
+    _isCacheValid = false;
+  }
+}
+
+// Initialize LogCapture immediately when this file is loaded
+// This ensures the listener is set up before any loggers are created
+// ignore: unused_element
+final _logCaptureInitializer = LogCapture();
+
+/// Simple wrapper around standard Dart Logger for backwards compatibility
+class SimplePrintLogger {
+  final Logger _logger;
+
+  SimplePrintLogger(String name) : _logger = Logger(name);
+
+  void debug(String message) {
+    _logger.fine(message);
+  }
+
+  void info(String message) {
+    _logger.info(message);
+  }
+
+  void warning(String message, {Object? error, StackTrace? stackTrace}) {
+    _logger.warning(message, error, stackTrace);
+  }
+
+  void error(String message, {Object? error, StackTrace? stackTrace}) {
+    _logger.severe(message, error, stackTrace);
+  }
 }