allow downloading CEF if it's not present

Signed-off-by: NikitaSkrynnik <[email protected]>

Author: NikitaSkrynnik

src-tauri/src/cef.rs

@@ -53,7 +53,12 @@ pub fn run() {
                 }
             }
         })
-        .invoke_handler(tauri::generate_handler!(get_args, cef::launch_cef))
+        .invoke_handler(tauri::generate_handler!(
+            get_args,
+            cef::is_cef_present,
+            cef::download_cef,
+            cef::launch_cef
+        ))
         .plugin(tauri_plugin_opener::init())
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/lib.rs

@@ -1,73 +1,28 @@
 import { createSignal, onMount, Show } from "solid-js";
-import { AppState } from "./state/state";
+import { AppEvent, AppState, Arguments, initializeApp } from "./state/state";
 import Browser from "./components/Browser";
 import Notification from "./components/Notification";
 import "./App.css";
-import { connect } from "cef-client";
-import { Channel, invoke } from "@tauri-apps/api/core";
-import { ProfileManager } from "./state/profiles";
-import { ShortcutPlugin } from "./state/plugins/shortcut";
+import { invoke } from "@tauri-apps/api/core";
 import Sidebar from "./components/sidebar";
+import { ShortcutPlugin } from "./state/plugins/shortcut";
 
-interface Arguments {
-  profiles_enabled: boolean;
-  cef_manager: string;
-  cef: string;
-}
-
-async function launchCEF(): Promise<AppState> {
-  let addr = await invoke('launch_cef');
-  let browser = await connect(addr as string);
-  return new AppState(browser);
-}
-
-async function connectToManager(managerAddress: string): Promise<AppState> {
-  let profileManager = new ProfileManager(managerAddress);
-  let profiles = await profileManager.getProfiles();
-  if (profiles.length === 0) {
-    throw new Error('No profiles found');
-  }
-
-  profileManager.setSelected(profiles[0]);
-  let client = await profileManager.connect(profiles[0]);
-  return new AppState(client, profileManager);
 
-}
 
-interface Event {
-  message: string;
-  type: 'info' | 'error';
-}
 
 function App() {
-  let [event, setEvent] = createSignal<Event>({ message: "", type: "info" });
+  let [event, setEvent] = createSignal<AppEvent>({ message: "Initializing App", type: "info" });
   let [app, setApp] = createSignal<AppState | null>(null);
 
   onMount(async () => {
-    try {
-      const args = await invoke("get_args") as Arguments;
-
-      let appState: AppState;
-      if (args.profiles_enabled) {
-        setEvent({ message: `Connecting to Huly CEF Manager on address ${args.cef_manager}`, type: "info" });
-        appState = await connectToManager(args.cef_manager);
-      } else if (args.cef !== "") {
-        setEvent({ message: `Connecting to Huly CEF on address ${args.cef}`, type: "info" });
-        const browser = await connect(args.cef);
-        appState = new AppState(browser);
-      } else {
-        appState = await launchCEF();
-      }
-
-      appState.addPlugin(new ShortcutPlugin());
-
-      setApp(appState);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      setEvent({ message: `Failed to initialize: ${errorMessage}`, type: "error" });
-    }
+    const args = await invoke("get_args") as Arguments;
+    let app = await initializeApp(args, setEvent);
+    if (!app) return;
+    app.addPlugin(new ShortcutPlugin());
+    setApp(app);
   });
 
+
   return (
     <Show when={app()} fallback={<Notification message={event().message} type={event().type} />}>
       {(app) =>

src/App.tsx

@@ -1,8 +1,10 @@
-import { Browser, LoadState, LoadStatus, Tab, TabEventStream } from "cef-client";
+import { Browser, connect, LoadState, LoadStatus, Tab, TabEventStream } from "cef-client";
 import { createStore, SetStoreFunction } from "solid-js/store";
 import { BrowserPlugin } from "./plugins/plugin";
 import { ProfileManager } from "./profiles";
 import { isURL, isFQDN } from "validator";
+import { invoke } from "@tauri-apps/api/core";
+import { Setter } from "solid-js";
 
 type TabId = number;
 
@@ -242,4 +244,77 @@ export class AppState {
         }
         return `https://www.google.com/search?q=${searchString}`;
     }
+}
+
+export interface Arguments {
+    profiles_enabled: boolean;
+    cef_manager: string;
+    cef: string;
+}
+
+export interface AppEvent {
+    message: string;
+    type: 'info' | 'error';
+}
+
+async function launchCEF(setEvent: Setter<AppEvent>): Promise<AppState | null> {
+    try {
+        setEvent({ message: 'Checking CEF presence...', type: 'info' });
+        let present = await invoke('is_cef_present');
+        if (!present) {
+            setEvent({ message: 'CEF not found, downloading...', type: 'info' });
+            await invoke('download_cef');
+        }
+
+        setEvent({ message: 'Launching CEF...', type: 'info' });
+        let addr = await invoke('launch_cef');
+        let browser = await connect(addr as string);
+        return new AppState(browser);
+    } catch (e) {
+        const errorMessage = "Failed to launch CEF: " + (e instanceof Error ? e.message : String(e));
+        setEvent({ message: errorMessage, type: 'error' });
+        return null;
+    }
+}
+
+async function connectToCefInstance(cefAddress: string, setEvent: Setter<AppEvent>): Promise<AppState | null> {
+    try {
+        setEvent({ message: 'Connecting to CEF instance...', type: 'info' });
+        let browser = await connect(cefAddress);
+        return new AppState(browser);
+    } catch (e) {
+        const errorMessage = "Failed to connect to CEF instance: " + (e instanceof Error ? e.message : String(e));
+        setEvent({ message: errorMessage, type: 'error' });
+        return null;
+    }
+}
+
+async function connectToManager(managerAddress: string, setEvent: Setter<AppEvent>): Promise<AppState | null> {
+    try {
+        setEvent({ message: 'Connecting...', type: 'info' });
+        const profileManager = new ProfileManager(managerAddress);
+        const profiles = await profileManager.getProfiles();
+        if (profiles.length === 0) {
+            setEvent({ message: 'No profiles found', type: 'error' });
+            return null;
+        }
+
+        profileManager.setSelected(profiles[0]);
+        const client = await profileManager.connect(profiles[0]);
+        return new AppState(client, profileManager);
+    } catch (e) {
+        const errorMessage = "Failed to connect to manager: " + (e instanceof Error ? e.message : String(e));
+        setEvent({ message: errorMessage, type: 'error' });
+        return null;
+    }
+}
+
+export async function initializeApp(args: Arguments, setEvent: Setter<AppEvent>): Promise<AppState | null> {
+    if (args.profiles_enabled) {
+        return await connectToManager(args.cef_manager, setEvent);
+    } else if (args.cef !== "") {
+        return await connectToCefInstance(args.cef, setEvent);
+    } else {
+        return await launchCEF(setEvent);
+    }
 }