Fix base URL determination

Makes it consistent with how jellyfin-web determines base URL

Author: Andrew Rabert

native/connectivityHelper.js

@@ -1,9 +1,10 @@
 window.jmpCheckServerConnectivity = (() => {
-    let checkInProgress = false;
+    let activeController = null;
 
-    return async function(url) {
-        if (checkInProgress) {
-            throw new Error('Connectivity check already in progress');
+    const checkFunc = async function(url) {
+        // Abort any in-progress check
+        if (activeController) {
+            activeController.abort();
         }
 
         // Wait for API
@@ -16,24 +17,48 @@ window.jmpCheckServerConnectivity = (() => {
             throw new Error('WebChannel not available');
         }
 
-        checkInProgress = true;
+        // Create abort controller for this check
+        const controller = new AbortController();
+        activeController = controller;
 
         return new Promise((resolve, reject) => {
-            const handler = (resultUrl, success) => {
-                if (resultUrl === url) {
+            // Handle abort
+            controller.signal.addEventListener('abort', () => {
+                if (handler) {
                     window.api.system.serverConnectivityResult.disconnect(handler);
-                    checkInProgress = false;
+                }
+                reject(new Error('Connection cancelled'));
+            });
+
+            let handler = (resultUrl, success, resolvedUrl) => {
+                if (resultUrl === url && !controller.signal.aborted) {
+                    window.api.system.serverConnectivityResult.disconnect(handler);
+                    handler = null;
+                    if (activeController === controller) {
+                        activeController = null;
+                    }
                     if (success) {
-                        resolve();
+                        resolve(resolvedUrl);
                     } else {
                         reject(new Error('Connection failed'));
                     }
                 }
             };
+
             window.api.system.serverConnectivityResult.connect(handler);
             window.api.system.checkServerConnectivity(url);
         });
     };
+
+    // Expose abort function for cancellation
+    checkFunc.abort = () => {
+        if (activeController) {
+            activeController.abort();
+            activeController = null;
+        }
+    };
+
+    return checkFunc;
 })();
 
 window.jmpFetchPage = (() => {

native/find-webclient.js

@@ -3,14 +3,18 @@ async function tryConnect(server) {
         if (!server.startsWith("http")) {
             server = "http://" + server;
         }
-        serverBaseURL = server.replace(/\/+$/, "");
 
         console.log("Checking connectivity to:", server);
 
-        await window.jmpCheckServerConnectivity(server);
+        const resolvedUrl = await window.jmpCheckServerConnectivity(server);
         console.log("Server connectivity check passed");
+        console.log("Resolved URL:", resolvedUrl);
+
+        // Save original URL but navigate to fully-resolved redirect
         window.jmpInfo.settings.main.userWebClient = server;
-        window.location = server;
+
+        // Navigation will clean up handlers, but do it explicitly
+        window.location = resolvedUrl;
 
         return true;
     } catch (e) {
@@ -54,16 +58,8 @@ const startConnecting = async () => {
     button.style.visibility = 'hidden';
     document.addEventListener('keydown', cancelOnEscape);
 
-    let connected = false;
-
-    while (!connected && isConnecting) {
-        connected = await tryConnect(server);
-
-        if (!connected && isConnecting) {
-            // Wait 5 seconds before retrying
-            await new Promise(resolve => setTimeout(resolve, 5000));
-        }
-    }
+    // C++ handles retries, just wait for result
+    const connected = await tryConnect(server);
 
     if (!connected) {
         isConnecting = false;
@@ -82,8 +78,17 @@ const startConnecting = async () => {
 const cancelConnection = () => {
     if (!isConnecting) return;
 
+    console.log("Cancelling connection");
     isConnecting = false;
 
+    // Cancel C++ connectivity check and abort JS promise
+    if (window.api && window.api.system) {
+        window.api.system.cancelServerConnectivity();
+    }
+    if (window.jmpCheckServerConnectivity.abort) {
+        window.jmpCheckServerConnectivity.abort();
+    }
+
     const address = document.getElementById('address');
     const title = document.getElementById('title');
     const spinner = document.getElementById('spinner');
@@ -160,16 +165,8 @@ document.addEventListener('keydown', (e) => {
         button.style.visibility = 'hidden';
         document.addEventListener('keydown', cancelOnEscape);
 
-        let connected = false;
-
-        while (!connected && isConnecting) {
-            connected = await tryConnect(savedServer);
-
-            if (!connected && isConnecting) {
-                // Wait 5 seconds before retrying
-                await new Promise(resolve => setTimeout(resolve, 5000));
-            }
-        }
+        // C++ handles retries, just wait for result
+        const connected = await tryConnect(savedServer);
 
         if (!connected) {
             // User cancelled or error - show UI