feat(.well-known): add .well-known/immich to reference API endpoint

mobile/lib/modules/login/providers/authentication.provider.dart

@@ -54,21 +54,15 @@ class AuthenticationNotifier extends StateNotifier<AuthenticationState> {
   Future<bool> login(
     String email,
     String password,
-    String serverEndpoint,
+    String serverUrl,
     bool isSavedLoginInfo,
   ) async {
-    // Store server endpoint to Hive and test endpoint
-    if (serverEndpoint[serverEndpoint.length - 1] == "/") {
-      var validUrl = serverEndpoint.substring(0, serverEndpoint.length - 1);
-      Hive.box(userInfoBox).put(serverEndpointKey, validUrl);
-    } else {
-      Hive.box(userInfoBox).put(serverEndpointKey, serverEndpoint);
-    }
-
-    // Check Server URL validity
     try {
-      _apiService.setEndpoint(Hive.box(userInfoBox).get(serverEndpointKey));
+      // Resolve API server endpoint from user provided serverUrl
+      final serverEndpoint = await _apiService.resolveEndpoint(serverUrl);
+      _apiService.setEndpoint(serverEndpoint);
       await _apiService.serverInfoApi.pingServer();
+      Hive.box(userInfoBox).put(serverEndpointKey, serverEndpoint);
     } catch (e) {
       debugPrint('Invalid Server Endpoint Url $e');
       return false;
@@ -90,7 +84,7 @@ class AuthenticationNotifier extends StateNotifier<AuthenticationState> {
 
       return setSuccessLoginInfo(
         accessToken: loginResponse.accessToken,
-        serverUrl: serverEndpoint,
+        serverUrl: serverUrl,
         isSavedLoginInfo: isSavedLoginInfo,
       );
     } catch (e) {
@@ -174,7 +168,6 @@ class AuthenticationNotifier extends StateNotifier<AuthenticationState> {
       var deviceInfo = await _deviceInfoService.getDeviceInfo();
       userInfoHiveBox.put(deviceIdKey, deviceInfo["deviceId"]);
       userInfoHiveBox.put(accessTokenKey, accessToken);
-      userInfoHiveBox.put(serverEndpointKey, serverUrl);
 
       state = state.copyWith(
         isAuthenticated: true,

mobile/lib/modules/login/services/oauth.service.dart

@@ -11,8 +11,10 @@ class OAuthService {
   OAuthService(this._apiService);
 
   Future<OAuthConfigResponseDto?> getOAuthServerConfig(
-    String serverEndpoint,
+    String serverUrl,
   ) async {
+    // Resolve API server endpoint from user provided serverUrl
+    final serverEndpoint = await _apiService.resolveEndpoint(serverUrl);
     _apiService.setEndpoint(serverEndpoint);
 
     return await _apiService.oAuthApi.generateConfig(

mobile/lib/modules/login/ui/login_form.dart

@@ -38,13 +38,17 @@ class LoginForm extends HookConsumerWidget {
         var urlText = serverEndpointController.text.trim();
 
         try {
-          var endpointUrl = Uri.tryParse(urlText);
+          var serverUrl = Uri.tryParse(urlText);
 
-          if (endpointUrl != null) {
+          if (serverUrl != null) {
             isLoading.value = true;
-            apiService.setEndpoint(endpointUrl.toString());
+            final serverEndpoint =
+                await apiService.resolveEndpoint(serverUrl.toString());
+            apiService.setEndpoint(serverEndpoint);
+            Hive.box(userInfoBox).put(serverEndpointKey, serverEndpoint);
+
             var loginConfig = await apiService.oAuthApi.generateConfig(
-              OAuthConfigDto(redirectUri: endpointUrl.toString()),
+              OAuthConfigDto(redirectUri: serverEndpoint),
             );
 
             if (loginConfig != null) {

mobile/lib/shared/providers/websocket.provider.dart

@@ -58,14 +58,15 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
 
     if (authenticationState.isAuthenticated) {
       var accessToken = Hive.box(userInfoBox).get(accessTokenKey);
-      var endpoint = Hive.box(userInfoBox).get(serverEndpointKey);
       try {
+        var endpoint = Uri.parse(Hive.box(userInfoBox).get(serverEndpointKey));
+
         debugPrint("Attempting to connect to websocket");
         // Configure socket transports must be specified
         Socket socket = io(
-          endpoint.toString().replaceAll('/api', ''),
+          endpoint.origin,
           OptionBuilder()
-              .setPath('/api/socket.io')
+              .setPath("${endpoint.path}/socket.io")
               .setTransports(['websocket'])
               .enableReconnection()
               .enableForceNew()

mobile/lib/shared/services/api.service.dart

@@ -1,4 +1,8 @@
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
 import 'package:openapi/api.dart';
+import 'package:http/http.dart';
 
 class ApiService {
   late ApiClient _apiClient;
@@ -22,6 +26,47 @@ class ApiService {
     deviceInfoApi = DeviceInfoApi(_apiClient);
   }
 
+  resolveEndpoint(String serverUrl) async {
+    // Sanitize URL to only include origin+path
+    final url = Uri.parse(serverUrl);
+    final baseUrl = "${url.origin}${url.path}";
+
+    // Remove trailing slash, if exists
+    final endpoint = baseUrl[baseUrl.length - 1] == "/"
+        ? baseUrl.substring(0, baseUrl.length - 1)
+        : baseUrl;
+
+    // Check for .well-known definition, otherwise assume endpoint is full API address
+    final apiEndpoint = await getWellKnownEndpoint(endpoint) ?? endpoint;
+    return apiEndpoint;
+  }
+
+  getWellKnownEndpoint(String baseUrl) async {
+    final Client client = Client();
+
+    try {
+      final res = await client.get(
+        Uri.parse("$baseUrl/.well-known/immich"),
+        headers: {"Accept": "application/json"},
+      );
+
+      if (res.statusCode == 200) {
+        final data = jsonDecode(res.body);
+        final endpoint = data['api']['endpoint'] as String;
+
+        if (endpoint.startsWith('/')) {
+          // Full URL is relative to base
+          return "$baseUrl$endpoint";
+        }
+        return endpoint;
+      }
+    } catch (e) {
+      debugPrint("Could not locate .well-known at $baseUrl: $e");
+    }
+
+    return null;
+  }
+
   setAccessToken(String accessToken) {
     _apiClient.addDefaultHeader('Authorization', 'Bearer $accessToken');
   }

mobile/lib/shared/views/splash_screen.dart

@@ -22,8 +22,11 @@ class SplashScreenPage extends HookConsumerWidget {
     void performLoggingIn() async {
       try {
         if (loginInfo != null) {
-          // Make sure API service is initialized
-          apiService.setEndpoint(loginInfo.serverUrl);
+          // Resolve API server endpoint from user provided serverUrl
+          final serverEndpoint =
+              await apiService.resolveEndpoint(loginInfo.serverUrl);
+          apiService.setEndpoint(serverEndpoint);
+          Hive.box(userInfoBox).put(serverEndpointKey, serverEndpoint);
 
           var isSuccess = await ref
               .read(authenticationProvider.notifier)