Phase A: generierter Dart-Client + DI-Foundation für Rust-Backend

OpenAPI-Generator-Setup:
- tool/generate_api_client.sh: Direkter Aufruf der openapi-generator-cli.jar
  (Java-CLI statt Dart-build_runner-Integration — vermeidet die
  analyzer-/source_gen-Version-Hölle mit json_serializable)
- tool/fetch_openapi_generator.sh: lädt die JAR (29 MB) nach (gitignored)
- openapi/holzleitner.json: Snapshot der Backend-Spec für reproduzierbare
  Generation
- packages/holzleitner_api/: generiertes Dart-Sub-Package (built_value +
  dio), per path-dep im Haupt-pubspec eingehängt

Netzwerk-Layer (lib/data/network/):
- BackendConfig: API- und Keycloak-Endpoints für Local-Dev (localhost
  wegen Keycloak-iss-Claim).
- AuthTokenProvider-Schnittstelle.
- DevPasswordGrantTokenProvider: Phase-A-Provider via Keycloak
  password-grant, Token-Caching mit Expiry-Check (Phase B ersetzt das
  durch flutter_appauth PKCE).
- HolzleitnerAuthInterceptor: dynamischer Bearer-Inject pro Request.
- HolzleitnerApiFactory: baut die generierte HolzleitnerApi-Klasse
  mit unserem Interceptor statt der vier Default-Auth-Interceptors.
- network_locator.registerNetworking(): get_it-Setup, in main() vor
  runApp() aufgerufen.

Clean-Arch-Scaffolding (lib/data/, lib/domain/):
- Verzeichnisstruktur für Phase C+D angelegt (mapper/, repository/,
  entity/, repository/) — befüllt sich in den Folge-Phasen.

Smoke-Test:
- tool/smoke_test_api.dart ruft /health (ungeschützt) und /me/cars
  (mit Bearer) via generiertem Client — grün gegen lokales Backend.

lib/data/network/auth_token_provider.dart

@@ -0,0 +1,9 @@
+/// Schnittstelle, über die HTTP-Interceptors einen aktuellen
+/// Access-Token beziehen. Phase A liefert das eine simple
+/// Password-Grant-Implementation; Phase B (Keycloak OIDC mit
+/// flutter_appauth) ersetzt sie durch eine echte PKCE-/Refresh-fähige.
+abstract interface class AuthTokenProvider {
+  /// Liefert einen aktuell gültigen Access-Token oder `null`, wenn
+  /// keine Session aktiv ist. Darf bei Bedarf einen Refresh anstoßen.
+  Future<String?> currentAccessToken();
+}

lib/data/network/backend_config.dart

@@ -0,0 +1,48 @@
+/// Endpoint-Konfiguration für das Rust-Backend.
+///
+/// Dies ist eine Übergangs-Konfiguration für Phase A der
+/// Backend-Migration. Sie wird in Phase D durch eine umfassendere
+/// `LocalDocuFrameConfiguration`-Ablösung ersetzt (oder die bestehende
+/// Konfiguration wird erweitert).
+///
+/// **Werte für lokale Entwicklung:**
+/// * iOS-Simulator + macOS-Host: `http://127.0.0.1:3000`
+/// * Android-Emulator: `http://10.0.2.2:3000`
+/// * Echtes Gerät im LAN: `http://<host-IP>:3000`
+///
+/// Default ist iOS-Simulator-tauglich. Für Android-Build vor dem
+/// Compile umstellen — eine Auto-Erkennung pro Platform kommt mit der
+/// Phase-D-Config.
+class BackendConfig {
+  const BackendConfig({
+    required this.apiBaseUrl,
+    required this.keycloakTokenEndpoint,
+    required this.keycloakClientId,
+  });
+
+  /// Basis-URL der Rust-API (kein abschließender Slash).
+  final String apiBaseUrl;
+
+  /// Vollständiger Token-Endpoint des Keycloak-Realms — Format:
+  /// `{issuer}/protocol/openid-connect/token`.
+  final String keycloakTokenEndpoint;
+
+  /// Public-Client-Id, die das Backend als `audience` erwartet
+  /// (aktuell `holzleitner-app`).
+  final String keycloakClientId;
+
+  /// Default-Konfiguration für lokale Entwicklung gegen das
+  /// Docker-Compose-Setup (Postgres + Keycloak + Backend).
+  ///
+  /// **Achtung Hostname:** Keycloak prägt das `iss`-Claim des Tokens
+  /// aus dem Hostnamen der Token-Endpoint-URL. Das Backend erwartet
+  /// `iss = http://localhost:8080/realms/holzleitner`, deshalb hier
+  /// `localhost` statt `127.0.0.1`. Auf Android-Emulator entsprechend
+  /// `10.0.2.2` setzen.
+  static const BackendConfig localDev = BackendConfig(
+    apiBaseUrl: 'http://localhost:3000',
+    keycloakTokenEndpoint:
+        'http://localhost:8080/realms/holzleitner/protocol/openid-connect/token',
+    keycloakClientId: 'holzleitner-app',
+  );
+}

lib/data/network/dev_password_grant_token_provider.dart

@@ -0,0 +1,73 @@
+import 'package:dio/dio.dart';
+
+import 'auth_token_provider.dart';
+
+/// **Nur für Phase A / Smoke-Tests.** Spricht direkt den Keycloak-
+/// Token-Endpoint mit `grant_type=password` an — bequem für
+/// Dev-Setups, in Produktion komplett ungeeignet (kein PKCE, keine
+/// Userinteraktion, Credentials in der App).
+///
+/// In Phase B ersetzt diese Klasse die KeycloakOidcTokenProvider-
+/// Implementierung, die auf flutter_appauth basiert.
+///
+/// Cached den Token im Speicher und erneuert ihn, sobald die
+/// Restlaufzeit unter 30 s fällt — kein eingebauter Refresh-Token-
+/// Flow, dafür einfach.
+class DevPasswordGrantTokenProvider implements AuthTokenProvider {
+  DevPasswordGrantTokenProvider({
+    required this.tokenEndpoint,
+    required this.clientId,
+    required this.username,
+    required this.password,
+    Dio? dio,
+  }) : _dio = dio ?? Dio();
+
+  final Dio _dio;
+  final String tokenEndpoint;
+  final String clientId;
+  final String username;
+  final String password;
+
+  String? _cachedToken;
+  DateTime? _expiresAt;
+
+  @override
+  Future<String?> currentAccessToken() async {
+    final now = DateTime.now();
+    final cached = _cachedToken;
+    final expiresAt = _expiresAt;
+    if (cached != null &&
+        expiresAt != null &&
+        expiresAt.isAfter(now.add(const Duration(seconds: 30)))) {
+      return cached;
+    }
+
+    final response = await _dio.post<Map<String, dynamic>>(
+      tokenEndpoint,
+      data: {
+        'grant_type': 'password',
+        'client_id': clientId,
+        'username': username,
+        'password': password,
+        'scope': 'openid',
+      },
+      options: Options(contentType: Headers.formUrlEncodedContentType),
+    );
+
+    final data = response.data;
+    if (data == null) {
+      throw StateError('Keycloak token endpoint lieferte leeren Body');
+    }
+    final token = data['access_token'] as String?;
+    final expiresIn = data['expires_in'] as int?;
+    if (token == null || expiresIn == null) {
+      throw StateError(
+        'Keycloak token endpoint lieferte unerwartete Antwort: $data',
+      );
+    }
+
+    _cachedToken = token;
+    _expiresAt = now.add(Duration(seconds: expiresIn));
+    return token;
+  }
+}

lib/data/network/holzleitner_api_factory.dart

@@ -0,0 +1,35 @@
+import 'package:dio/dio.dart';
+import 'package:holzleitner_api/holzleitner_api.dart';
+
+import 'auth_token_provider.dart';
+import 'backend_config.dart';
+import 'holzleitner_auth_interceptor.dart';
+
+/// Baut den generierten `HolzleitnerApi`-Client mit:
+/// * eigener `Dio`-Instanz (Base-URL + Timeouts aus [BackendConfig]),
+/// * **ohne** die vier Default-Auth-Interceptors des Generators —
+///   stattdessen wird unser [HolzleitnerAuthInterceptor] gehängt.
+///
+/// Auf diese Weise bleibt die Token-Quelle pluggable
+/// ([AuthTokenProvider]), und Phase B (Keycloak OIDC) kann die
+/// Provider-Implementierung austauschen, ohne den Rest des Codes
+/// anzufassen.
+HolzleitnerApi buildHolzleitnerApi({
+  required BackendConfig config,
+  required AuthTokenProvider tokenProvider,
+}) {
+  final dio = Dio(
+    BaseOptions(
+      baseUrl: config.apiBaseUrl,
+      connectTimeout: const Duration(seconds: 10),
+      receiveTimeout: const Duration(seconds: 30),
+      sendTimeout: const Duration(seconds: 30),
+      headers: const {'Accept': 'application/json'},
+    ),
+  );
+
+  return HolzleitnerApi(
+    dio: dio,
+    interceptors: [HolzleitnerAuthInterceptor(tokenProvider)],
+  );
+}

lib/data/network/holzleitner_auth_interceptor.dart

@@ -0,0 +1,33 @@
+import 'package:dio/dio.dart';
+
+import 'auth_token_provider.dart';
+
+/// Dio-Interceptor, der pro Request den aktuellen Access-Token vom
+/// `AuthTokenProvider` zieht und als `Authorization: Bearer …`-Header
+/// anhängt. Provider-Fehler werden geloggt, der Request läuft trotzdem
+/// weiter — das Backend antwortet dann mit 401, was der reguläre
+/// Error-Handling-Pfad behandelt.
+class HolzleitnerAuthInterceptor extends Interceptor {
+  HolzleitnerAuthInterceptor(this._tokenProvider);
+
+  final AuthTokenProvider _tokenProvider;
+
+  @override
+  Future<void> onRequest(
+    RequestOptions options,
+    RequestInterceptorHandler handler,
+  ) async {
+    try {
+      final token = await _tokenProvider.currentAccessToken();
+      if (token != null) {
+        options.headers['Authorization'] = 'Bearer $token';
+      }
+    } catch (e, stack) {
+      // TODO Phase B: hier ein strukturiertes Logging-Framework
+      // einhängen statt print.
+      // ignore: avoid_print
+      print('[HolzleitnerAuthInterceptor] Token-Provider hat geworfen: $e\n$stack');
+    }
+    handler.next(options);
+  }
+}

lib/data/network/network_locator.dart

@@ -0,0 +1,41 @@
+import 'package:get_it/get_it.dart';
+import 'package:holzleitner_api/holzleitner_api.dart';
+
+import 'auth_token_provider.dart';
+import 'backend_config.dart';
+import 'dev_password_grant_token_provider.dart';
+import 'holzleitner_api_factory.dart';
+
+/// Registriert das HTTP-/API-Subsystem im globalen GetIt-Locator.
+///
+/// Aufruf bewusst nicht im AppBloc-Lifecycle, sondern in `main()` vor
+/// dem `runApp` — die API-Klassen sind über die gesamte App-Lebensdauer
+/// stabil und brauchen keine Reaktion auf App-Events.
+///
+/// Phase A nutzt die `DevPasswordGrantTokenProvider`-Implementation.
+/// Phase B wird hier den OIDC-PKCE-Provider einhängen und die
+/// Dev-Implementation komplett entfernen.
+void registerNetworking({
+  required GetIt locator,
+  BackendConfig config = BackendConfig.localDev,
+  String testfahrerUsername = 'testfahrer',
+  String testfahrerPassword = 'test',
+}) {
+  locator.registerSingleton<BackendConfig>(config);
+
+  locator.registerSingleton<AuthTokenProvider>(
+    DevPasswordGrantTokenProvider(
+      tokenEndpoint: config.keycloakTokenEndpoint,
+      clientId: config.keycloakClientId,
+      username: testfahrerUsername,
+      password: testfahrerPassword,
+    ),
+  );
+
+  locator.registerSingleton<HolzleitnerApi>(
+    buildHolzleitnerApi(
+      config: config,
+      tokenProvider: locator<AuthTokenProvider>(),
+    ),
+  );
+}

lib/main.dart

@@ -3,6 +3,7 @@ import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:get_it/get_it.dart';
 import 'package:hl_lieferservice/bloc/app_bloc.dart';
 import 'package:hl_lieferservice/bloc/app_events.dart';
+import 'package:hl_lieferservice/data/network/network_locator.dart';
 import 'package:hl_lieferservice/feature/settings/bloc/settings_bloc.dart';
 import 'package:hl_lieferservice/feature/settings/bloc/settings_event.dart';
 import 'package:hl_lieferservice/widget/app.dart';
@@ -10,6 +11,12 @@ import 'package:hl_lieferservice/widget/app.dart';
 final locator = GetIt.instance;
 
 void main() {
+  // Backend-Migration Phase A: HTTP-Stack + Token-Provider registrieren,
+  // bevor irgendein Bloc starten kann. Wirft eine Compile-Sicherheit
+  // hin, dass `HolzleitnerApi` ab hier per `locator<HolzleitnerApi>()`
+  // verfügbar ist.
+  registerNetworking(locator: locator);
+
   runApp(MultiBlocProvider(providers: [
     BlocProvider(create: (context) => AppBloc(),),
     BlocProvider(create: (context) => SettingsBloc())