Merge pull request #14 from oviron/byedpi-test-routing

feat(byedpi): test-driven host routing + update-407 fix

Author: oviron

CHANGELOG.md

@@ -1,3 +1,11 @@
+## v0.13.11
+
+- Test-driven host routing: applying a strategy from the test now routes only the hosts it verified through ByeDPI; hosts it can't pierce fall back to the VPN (no longer broken). Apply shows the ByeDPI/VPN split
+
+- Strategy test is now a dashboard: per-strategy results + timestamps persist and render from cache; the active strategy is badged
+
+- Fix: updating strategies through the VPN no longer fails with 407 (answers the local proxy's inbound-auth challenge)
+
 ## v0.13.10
 
 - In-app ByeDPI strategy auto-test: a Strategy-test screen runs each strategy through a standalone byedpi SOCKS proxy and ranks them by how well they reach the test sites on the current network; apply the best in one tap

lib/byedpi/strategy_update.dart

@@ -1,5 +1,10 @@
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+import 'package:dio/io.dart';
 import 'package:fl_clash/byedpi/strategy_args.dart';
-import 'package:fl_clash/common/request.dart';
+import 'package:fl_clash/common/inbound_auth.dart';
+import 'package:fl_clash/controller.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
 const kStrategiesUrl =
@@ -13,12 +18,46 @@ Future<DateTime?> strategiesLastUpdate() async {
   return ms == null ? null : DateTime.fromMillisecondsSinceEpoch(ms);
 }
 
-// Fetch the strategy set from [kStrategiesUrl] (routed through mihomo when the
-// VPN is up, via request._clashDio), validate, atomically write the on-disk
-// override and stamp the update time. Returns the strategy count. Throws on
-// fetch/parse failure — the previous on-disk/bundled set is left untouched.
+// Route through the local mixed-port when the VPN is up (so a blocked release
+// host is reachable), else direct. The inbound carries auth (see
+// inbound_auth.dart), so we must answer the proxy's 407 with the stored
+// credentials — `request._clashDio` doesn't, which is why the generic fetch
+// failed. authenticateProxy matches whatever realm mihomo challenges with.
+Dio _buildDio() {
+  final mixedPort = appController.config.patchClashConfig.mixedPort;
+  final viaProxy = appController.isStart;
+  final dio = Dio();
+  dio.httpClientAdapter = IOHttpClientAdapter(
+    createHttpClient: () {
+      final client = HttpClient();
+      client.badCertificateCallback = (_, _, _) => true;
+      client.findProxy = (_) =>
+          viaProxy ? 'PROXY localhost:$mixedPort' : 'DIRECT';
+      client.authenticateProxy = (host, port, scheme, realm) async {
+        final pwd = await inboundAuthPassword();
+        if (pwd == null || pwd.isEmpty) return false;
+        client.addProxyCredentials(
+          host,
+          port,
+          realm ?? '',
+          HttpClientBasicCredentials(inboundAuthUser, pwd),
+        );
+        return true;
+      };
+      return client;
+    },
+  );
+  return dio;
+}
+
+// Fetch the strategy set from [kStrategiesUrl], validate, atomically write the
+// on-disk override and stamp the update time. Returns the strategy count.
+// Throws on fetch/parse failure — the previous on-disk/bundled set is kept.
 Future<int> updateStrategiesFromRemote() async {
-  final res = await request.getTextResponseForUrl(kStrategiesUrl);
+  final res = await _buildDio().get<String>(
+    kStrategiesUrl,
+    options: Options(responseType: ResponseType.plain),
+  );
   final raw = res.data ?? '';
   final list = parseStrategyList(raw);
   await writeStrategyList(raw);

lib/byedpi/test_store.dart

@@ -0,0 +1,54 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:path/path.dart';
+import 'package:path_provider/path_provider.dart';
+
+Future<String> _supportDir() async =>
+    (await getApplicationSupportDirectory()).path;
+
+Future<void> _atomicWrite(String path, String contents) async {
+  final tmp = File('$path.tmp');
+  await tmp.writeAsString(contents);
+  await tmp.rename(path);
+}
+
+// --- exclude list: hosts the active strategy failed in its last test.
+// engine routing uses readHostList() − exclude (see providers/state.dart). ---
+
+Future<String> _excludePath() async =>
+    join(await _supportDir(), 'byedpi-exclude.json');
+
+Future<Set<String>> readExclude() async {
+  final f = File(await _excludePath());
+  if (!f.existsSync()) return const {};
+  try {
+    final list = jsonDecode(await f.readAsString()) as List<dynamic>;
+    return list.map((e) => e.toString()).toSet();
+  } catch (_) {
+    return const {};
+  }
+}
+
+Future<void> writeExclude(Iterable<String> hosts) =>
+    _excludePath().then((p) => _atomicWrite(p, jsonEncode(hosts.toList())));
+
+// --- test results cache: id -> { percent, timestamp(ms), sites:[{site,ok,total}] }.
+// Lets the dashboard render from cache and keep per-strategy dates. ---
+
+Future<String> _resultsPath() async =>
+    join(await _supportDir(), 'byedpi-test-results.json');
+
+Future<Map<String, dynamic>> readTestResults() async {
+  final f = File(await _resultsPath());
+  if (!f.existsSync()) return {};
+  try {
+    final decoded = jsonDecode(await f.readAsString());
+    return decoded is Map<String, dynamic> ? decoded : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+Future<void> writeTestResults(Map<String, dynamic> results) =>
+    _resultsPath().then((p) => _atomicWrite(p, jsonEncode(results)));

lib/common/inbound_auth.dart

@@ -7,6 +7,12 @@ const _kInboundAuthAlphabet =
     'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz0123456789';
 const _kInboundAuthLength = 24;
 
+// Exposed so app-side clients going through the local mixed-port can answer its
+// 407 challenge (the inbound auth below is otherwise opaque to them).
+const inboundAuthUser = _kInboundAuthUser;
+
+Future<String?> inboundAuthPassword() => preferences.getInboundAuth();
+
 String _generateInboundPassword() {
   final r = Random.secure();
   final buf = StringBuffer();

lib/providers/state.dart

@@ -1,5 +1,6 @@
 import 'package:dynamic_color/dynamic_color.dart';
 import 'package:fl_clash/byedpi/host_list.dart';
+import 'package:fl_clash/byedpi/test_store.dart';
 import 'package:fl_clash/common/common.dart';
 import 'package:fl_clash/core/controller.dart';
 import 'package:fl_clash/enum/enum.dart';
@@ -614,7 +615,13 @@ Future<SetupState> setupState(Ref ref, int? profileId) async {
       : [];
   final byeDpiSettings = ref.watch(byeDpiSettingsProvider);
   final hostListText = await readHostList();
-  final byeDpiHostList = hostListText.split('\n');
+  // Route to byedpi only hosts the active strategy verified (list − exclude);
+  // excluded hosts get no byedpi rule and fall to normal routing (VPN).
+  final exclude = await readExclude();
+  final byeDpiHostList = hostListText
+      .split('\n')
+      .where((h) => !exclude.contains(h.trim()))
+      .toList();
   return SetupState(
     profileId: profileId,
     profileLastUpdateDate: profileLastUpdateDate,

lib/providers/strategy_test.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 import 'dart:convert';
 
 import 'package:fl_clash/byedpi/host_list.dart';
+import 'package:fl_clash/byedpi/test_store.dart';
 import 'package:fl_clash/controller.dart';
 import 'package:fl_clash/plugins/service.dart';
 import 'package:fl_clash/providers/byedpi.dart';
@@ -26,6 +27,7 @@ class StrategyTestResult {
   final int success;
   final int totalRequests;
   final List<SiteOutcome> sites;
+  final int? testedAt; // epoch ms
 
   const StrategyTestResult({
     required this.id,
@@ -34,9 +36,18 @@ class StrategyTestResult {
     required this.success,
     required this.totalRequests,
     required this.sites,
+    this.testedAt,
   });
+
+  List<String> get failedHosts => [
+    for (final s in sites)
+      if (s.ok == 0) s.site,
+  ];
 }
 
+// (byedpiCount, vpnCount) reported back to the UI on apply().
+typedef ApplySplit = ({int byedpi, int vpn});
+
 class StrategyTestState {
   final TestPhase phase;
   final int completed;
@@ -72,8 +83,9 @@ class StrategyTestState {
 
 // Drives the in-app strategy auto-test (bydpi flavor). The native side runs
 // byedpi standalone (no VPN tun) per strategy and streams progress; we snapshot
-// and pause the VPN for the run, then restore it. Apply selects the winning id
-// through the existing preset model.
+// and pause the VPN for the run, then restore it. Results persist to a cache so
+// the dashboard renders without re-testing. Apply selects the winning id AND
+// rewrites the byedpi exclude list (hosts that strategy failed → routed via VPN).
 @riverpod
 class StrategyTestController extends _$StrategyTestController {
   Service get _svc => Service();
@@ -83,6 +95,40 @@ class StrategyTestController extends _$StrategyTestController {
   @override
   StrategyTestState build() => const StrategyTestState();
 
+  // Render last results from the on-disk cache (no re-test).
+  Future<void> loadCached() async {
+    if (state.phase == TestPhase.running || state.results.isNotEmpty) return;
+    final cache = await readTestResults();
+    if (cache.isEmpty) return;
+    final results = <StrategyTestResult>[];
+    cache.forEach((id, raw) {
+      if (raw is! Map) return;
+      results.add(_resultFromCache(id, Map<String, dynamic>.from(raw)));
+    });
+    results.sort((a, b) => b.percent.compareTo(a.percent));
+    state = StrategyTestState(phase: TestPhase.done, results: results);
+  }
+
+  StrategyTestResult _resultFromCache(String id, Map<String, dynamic> raw) {
+    final sites = [
+      for (final s in (raw['sites'] as List? ?? []))
+        SiteOutcome(
+          (s as Map)['site'].toString(),
+          (s['ok'] as num).toInt(),
+          (s['total'] as num).toInt(),
+        ),
+    ];
+    return StrategyTestResult(
+      id: id,
+      label: (raw['label'] ?? id).toString(),
+      percent: (raw['percent'] as num?)?.toInt() ?? 0,
+      success: sites.fold(0, (a, s) => a + s.ok),
+      totalRequests: sites.fold(0, (a, s) => a + s.total),
+      sites: sites,
+      testedAt: (raw['timestamp'] as num?)?.toInt(),
+    );
+  }
+
   Future<void> run({
     int requests = 1,
     int timeout = 5,
@@ -176,17 +222,57 @@ class StrategyTestController extends _$StrategyTestController {
       await appController.updateStatus(true);
       _wasVpnOn = false;
     }
-    final sorted = [...state.results]
-      ..sort((a, b) => b.percent.compareTo(a.percent));
+    final now = DateTime.now().millisecondsSinceEpoch;
+    final stamped = [
+      for (final r in state.results)
+        StrategyTestResult(
+          id: r.id,
+          label: r.label,
+          percent: r.percent,
+          success: r.success,
+          totalRequests: r.totalRequests,
+          sites: r.sites,
+          testedAt: now,
+        ),
+    ]..sort((a, b) => b.percent.compareTo(a.percent));
+    await _persist(stamped);
     state = StrategyTestState(
       phase: TestPhase.done,
       completed: state.completed,
       total: state.total,
-      results: sorted,
+      results: stamped,
       error: error,
     );
   }
 
-  Future<void> apply(String id) =>
-      ref.read(byeDpiSettingsProvider.notifier).setPreset(id);
+  // Merge this run's results into the on-disk cache (other strategies' prior
+  // entries survive), so per-strategy dates and offline render work.
+  Future<void> _persist(List<StrategyTestResult> results) async {
+    final cache = await readTestResults();
+    for (final r in results) {
+      cache[r.id] = {
+        'label': r.label,
+        'percent': r.percent,
+        'timestamp': r.testedAt,
+        'sites': [
+          for (final s in r.sites)
+            {'site': s.site, 'ok': s.ok, 'total': s.total},
+        ],
+      };
+    }
+    await writeTestResults(cache);
+  }
+
+  // Apply a strategy: make it active AND route its failed hosts via VPN by
+  // writing them to the exclude list, then re-apply the profile so the byedpi
+  // routing rules rebuild. Returns the byedpi/VPN split for the UI.
+  Future<ApplySplit> apply(String id) async {
+    final result = state.results.where((r) => r.id == id).firstOrNull;
+    final failed = result?.failedHosts ?? const <String>[];
+    await writeExclude(failed);
+    await ref.read(byeDpiSettingsProvider.notifier).setPreset(id);
+    await appController.applyProfile(silence: true);
+    final total = result?.sites.length ?? 0;
+    return (byedpi: total - failed.length, vpn: failed.length);
+  }
 }