Show slim launch modal when existing server is protocol-activated

Author: datah4zard

app/components/LaunchServerModal.tsx

@@ -0,0 +1,41 @@
+import Modal from "react-bootstrap/Modal";
+
+import Button from "./Button";
+
+import { ServerEntry } from "@/app/types";
+
+export default function LaunchServerModal({
+  server,
+  show,
+  setShow,
+  launchServer,
+}: {
+  server?: ServerEntry;
+  show: boolean;
+  setShow: (newShow: boolean) => void;
+  launchServer: (uuid: string | undefined) => void;
+}) {
+  return (
+    <Modal show={show} onHide={() => setShow(false)} centered={true}>
+      <Modal.Header>
+        <Modal.Title>{server?.description}</Modal.Title>
+      </Modal.Header>
+      <Modal.Body>This server is already in your server list.</Modal.Body>
+      <Modal.Footer>
+        <Button
+          onClick={() => setShow(false)}
+          variant="primary"
+          text="Cancel"
+        />
+        <Button
+          onClick={() => {
+            setShow(false);
+            launchServer(server?.uuid);
+          }}
+          variant="success"
+          text="Launch"
+        />
+      </Modal.Footer>
+    </Modal>
+  );
+}

app/page.tsx

@@ -49,6 +49,7 @@ import {
 import ForgotPasswordModal from "./components/ForgotPasswordModal";
 import ConfirmationModal from "./components/ConfirmationModal";
 import { useRouter } from "next/navigation";
+import LaunchServerModal from "./components/LaunchServerModal";
 
 const DEFAULT_TAGLINE =
   "Welcome to OpenFusion.\nSelect a server from the list below to get started.";
@@ -70,7 +71,7 @@ export default function Home() {
   const [servers, setServers] = useState<ServerEntry[]>([]);
   const [versions, setVersions] = useState<VersionEntry[]>([]);
 
-  const [selectedIdx, setSelectedIdx] = useState<number>(-1);
+  const [selectedServerUuid, setSelectedServerUuid] = useState<string>();
   const [currentSession, setCurrentSession] = useState<
     LoginSession | undefined
   >(undefined);
@@ -82,6 +83,7 @@ export default function Home() {
   const [addServerDetails, setAddServerDetails] = useState<NewServerDetails>();
   const [showEditModal, setShowEditModal] = useState(false);
   const [showDeleteModal, setShowDeleteModal] = useState(false);
+  const [showLaunchModal, setShowLaunchModal] = useState(false);
 
   const [showLoginModal, setShowLoginModal] = useState(false);
   const [showForgotPasswordModal, setShowForgotPasswordModal] = useState(false);
@@ -107,22 +109,17 @@ export default function Home() {
     setShowAddModal(true);
   };
 
+  const openLaunchServer = (uuid: string) => {
+    setSelectedServer(uuid);
+    setShowLaunchModal(true);
+  };
+
   const getSelectedServer = () => {
-    if (selectedIdx >= 0 && selectedIdx < servers.length) {
-      return servers[selectedIdx];
-    }
-    return undefined;
+    return servers.find((server) => server.uuid == selectedServerUuid);
   };
 
   const setSelectedServer = (uuid?: string) => {
-    if (uuid) {
-      const idx = servers.findIndex((server) => server.uuid == uuid);
-      if (idx >= 0) {
-        setSelectedIdx(idx);
-      }
-    } else {
-      setSelectedIdx(-1);
-    }
+    setSelectedServerUuid(uuid);
     setCurrentSession(undefined);
   };
 
@@ -275,17 +272,6 @@ export default function Home() {
     if (e.key === "Escape") {
       setSelectedServer(undefined);
     }
-
-    // Server selector controls
-    // const modulo = servers.length;
-    // if (e.key === "ArrowUp" || e.key === "ArrowLeft") {
-    //   const newIdx = (selectedIdx <= 0 ? modulo - 1 : (selectedIdx - 1));
-    //   setSelectedIdx(newIdx);
-    // }
-    // if (e.key === "ArrowDown" || e.key === "ArrowRight") {
-    //   const newIdx = (selectedIdx + 1) % modulo;
-    //   setSelectedIdx(newIdx);
-    // }
   };
 
   const doInit = async () => {
@@ -533,6 +519,13 @@ export default function Home() {
     }
   };
 
+  const launchServer = async (serverUuid?: string) => {
+    if (serverUuid) {
+      setConnecting(true);
+      onConnect(serverUuid);
+    }
+  };
+
   const sendOneTimePassword = async (email: string) => {
     try {
       await invoke("send_otp", {
@@ -585,7 +578,10 @@ export default function Home() {
         for (const activation of pending) {
           switch (activation.type) {
             case "add_server":
-              openAddServer(activation.details);
+              openAddServer(activation.payload);
+              break;
+            case "show_existing_server":
+              openLaunchServer(activation.payload);
               break;
           }
         }
@@ -616,7 +612,7 @@ export default function Home() {
     return () => {
       window.removeEventListener("keydown", handleKeydown);
     };
-  }, [servers, selectedIdx]);
+  }, [servers, selectedServerUuid]);
 
   // Padding for custom titlebar
   useEffect(() => {
@@ -758,6 +754,12 @@ export default function Home() {
         setShow={setShowDeleteModal}
         deleteServer={deleteServer}
       />
+      <LaunchServerModal
+        server={getSelectedServer()}
+        show={showLaunchModal}
+        setShow={setShowLaunchModal}
+        launchServer={launchServer}
+      />
       <LoginModal
         server={getSelectedServer()}
         show={showLoginModal}

app/types.ts

@@ -13,10 +13,9 @@ export type NewServerDetails = {
   endpoint?: string;
 };
 
-export type ProtocolActivation = {
-  type: string;
-  details: NewServerDetails;
-};
+export type ProtocolActivation =
+  | { type: "add_server"; payload: NewServerDetails }
+  | { type: "show_existing_server"; payload: string };
 
 export type Servers = {
   servers: ServerEntry[];

src-tauri/src/state.rs

@@ -549,6 +549,10 @@ impl From<FlatServer> for Server {
     }
 }
 impl Server {
+    pub fn get_uuid(&self) -> Uuid {
+        self.uuid
+    }
+
     pub fn get_description(&self) -> Option<String> {
         self.description.clone()
     }
@@ -665,6 +669,26 @@ impl Servers {
         }
         Err(format!("Server with UUID {} not found", entry.uuid).into())
     }
+
+    pub fn find_simple_entry(&self, ip: &str, version: &str) -> Option<&Server> {
+        self.servers.iter().find(|s| match &s.info {
+            ServerInfo::Simple {
+                ip: server_ip,
+                version: server_version,
+            } => server_ip == ip && server_version == version,
+            ServerInfo::Endpoint { .. } => false,
+        })
+    }
+
+    pub fn find_endpoint_entry(&self, endpoint: &str) -> Option<&Server> {
+        self.servers.iter().find(|s| match &s.info {
+            ServerInfo::Endpoint {
+                endpoint: server_endpoint,
+                ..
+            } => server_endpoint == endpoint,
+            ServerInfo::Simple { .. } => false,
+        })
+    }
 }
 
 impl From<FlatServers> for Servers {

src-tauri/src/util.rs

@@ -452,20 +452,54 @@ pub(crate) fn send_alert(app_handle: tauri::AppHandle, variant: AlertVariant, me
 }
 
 #[derive(Debug, Clone, Serialize)]
-#[serde(tag = "type", content = "details", rename_all = "snake_case")]
+#[serde(tag = "type", content = "payload", rename_all = "snake_case")]
 pub(crate) enum ProtocolActivation {
     AddServer(NewServerDetails),
+    ShowExistingServer(Uuid),
 }
 
-pub(crate) fn queue_activation(app_handle: tauri::AppHandle, activation: ProtocolActivation) {
+async fn queue_activation(app_handle: tauri::AppHandle, activation: ProtocolActivation) {
+    // since this might run on cold start, the app state might not be ready yet
+    state::wait_for_app_state().await;
+    let state = app_handle.state::<tokio::sync::Mutex<AppState>>();
+    state.lock().await.pending_activations.push(activation);
+
+    if let Err(e) = app_handle.emit("activation_pending", ()) {
+        error!("Failed to emit activation pending event: {}", e);
+    }
+}
+
+fn handle_server_activation(app_handle: tauri::AppHandle, details: NewServerDetails) {
     tauri::async_runtime::spawn(async move {
         state::wait_for_app_state().await;
         let state = app_handle.state::<tokio::sync::Mutex<AppState>>();
-        state.lock().await.pending_activations.push(activation);
+        let existing_server_uuid = {
+            let state = state.lock().await;
+
+            // Check if the server is already added.
+            if let Some(endpoint) = &details.endpoint {
+                state
+                    .servers
+                    .find_endpoint_entry(endpoint)
+                    .map(|s| s.get_uuid())
+            } else if let Some(ip) = &details.ip
+                && let Some(version) = &details.version
+            {
+                state
+                    .servers
+                    .find_simple_entry(ip, version)
+                    .map(|s| s.get_uuid())
+            } else {
+                None
+            }
+        };
 
-        if let Err(e) = app_handle.emit("activation_pending", ()) {
-            error!("Failed to emit activation pending event: {}", e);
-        }
+        let activation = match existing_server_uuid {
+            Some(uuid) => ProtocolActivation::ShowExistingServer(uuid),
+            None => ProtocolActivation::AddServer(details),
+        };
+
+        queue_activation(app_handle, activation).await;
     });
 }
 
@@ -486,15 +520,15 @@ pub(crate) fn handle_protocol_activation(app_handle: tauri::AppHandle, uri: &str
     debug!("Protocol activation params: {:?}", params);
 
     match command {
-        "add-server" => {
-            queue_activation(
+        "server" => {
+            handle_server_activation(
                 app_handle,
-                ProtocolActivation::AddServer(NewServerDetails {
+                NewServerDetails {
                     description: params.get("description").cloned().unwrap_or_default(),
                     ip: params.get("ip").cloned(),
                     version: params.get("version").cloned(),
                     endpoint: params.get("endpoint").cloned(),
-                }),
+                },
             );
         }
         _ => {