Refactor logs

lib/features/log/data/log_data_providers.dart

@@ -0,0 +1,23 @@
+import 'package:hiddify/features/log/data/log_path_resolver.dart';
+import 'package:hiddify/features/log/data/log_repository.dart';
+import 'package:hiddify/services/service_providers.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'log_data_providers.g.dart';
+
+@Riverpod(keepAlive: true)
+Future<LogRepository> logRepository(LogRepositoryRef ref) async {
+  final repo = LogRepositoryImpl(
+    singbox: ref.watch(singboxServiceProvider),
+    logPathResolver: ref.watch(logPathResolverProvider),
+  );
+  await repo.init().getOrElse((l) => throw l).run();
+  return repo;
+}
+
+@Riverpod(keepAlive: true)
+LogPathResolver logPathResolver(LogPathResolverRef ref) {
+  return LogPathResolver(
+    ref.watch(filesEditorServiceProvider).dirs.workingDir,
+  );
+}

lib/features/log/data/log_parser.dart

@@ -0,0 +1,33 @@
+// ignore_for_file: parameter_assignments
+
+import 'package:dartx/dartx.dart';
+import 'package:hiddify/features/log/model/log_entity.dart';
+import 'package:hiddify/features/log/model/log_level.dart';
+import 'package:tint/tint.dart';
+
+abstract class LogParser {
+  static LogEntity parseSingbox(String log) {
+    log = log.strip();
+    DateTime? time;
+    if (log.length > 25) {
+      time = DateTime.tryParse(log.substring(6, 25));
+    }
+    if (time != null) {
+      log = log.substring(26);
+    }
+    final level = LogLevel.values.firstOrNullWhere(
+      (e) {
+        if (log.startsWith(e.name.toUpperCase())) {
+          log = log.removePrefix(e.name.toUpperCase());
+          return true;
+        }
+        return false;
+      },
+    );
+    return LogEntity(
+      level: level,
+      time: time,
+      message: log.trim(),
+    );
+  }
+}

lib/features/log/data/log_path_resolver.dart

@@ -0,0 +1,19 @@
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+
+class LogPathResolver {
+  const LogPathResolver(this._workingDir);
+
+  final Directory _workingDir;
+
+  Directory get directory => _workingDir;
+
+  File coreFile() {
+    return File(p.join(directory.path, "box.log"));
+  }
+
+  File appFile() {
+    return File(p.join(directory.path, "app.log"));
+  }
+}

lib/features/log/data/log_repository.dart

@@ -0,0 +1,70 @@
+import 'package:fpdart/fpdart.dart';
+import 'package:hiddify/data/repository/exception_handlers.dart';
+import 'package:hiddify/features/log/data/log_parser.dart';
+import 'package:hiddify/features/log/data/log_path_resolver.dart';
+import 'package:hiddify/features/log/model/log_entity.dart';
+import 'package:hiddify/features/log/model/log_failure.dart';
+import 'package:hiddify/services/singbox/singbox_service.dart';
+import 'package:hiddify/utils/custom_loggers.dart';
+
+abstract interface class LogRepository {
+  TaskEither<LogFailure, Unit> init();
+  Stream<Either<LogFailure, List<LogEntity>>> watchLogs();
+  TaskEither<LogFailure, Unit> clearLogs();
+}
+
+class LogRepositoryImpl
+    with ExceptionHandler, InfraLogger
+    implements LogRepository {
+  LogRepositoryImpl({
+    required this.singbox,
+    required this.logPathResolver,
+  });
+
+  final SingboxService singbox;
+  final LogPathResolver logPathResolver;
+
+  @override
+  TaskEither<LogFailure, Unit> init() {
+    return exceptionHandler(
+      () async {
+        if (!await logPathResolver.directory.exists()) {
+          await logPathResolver.directory.create(recursive: true);
+        }
+        if (await logPathResolver.coreFile().exists()) {
+          await logPathResolver.coreFile().writeAsString("");
+        } else {
+          await logPathResolver.coreFile().create(recursive: true);
+        }
+        if (await logPathResolver.appFile().exists()) {
+          await logPathResolver.appFile().writeAsString("");
+        } else {
+          await logPathResolver.appFile().create(recursive: true);
+        }
+        return right(unit);
+      },
+      LogUnexpectedFailure.new,
+    );
+  }
+
+  @override
+  Stream<Either<LogFailure, List<LogEntity>>> watchLogs() {
+    return singbox
+        .watchLogs(logPathResolver.coreFile().path)
+        .map((event) => event.map(LogParser.parseSingbox).toList())
+        .handleExceptions(
+      (error, stackTrace) {
+        loggy.warning("error watching logs", error, stackTrace);
+        return LogFailure.unexpected(error, stackTrace);
+      },
+    );
+  }
+
+  @override
+  TaskEither<LogFailure, Unit> clearLogs() {
+    return exceptionHandler(
+      () => singbox.clearLogs().mapLeft(LogFailure.unexpected).run(),
+      LogFailure.unexpected,
+    );
+  }
+}