client mode added

daemon/src/config.rs

@@ -7,6 +7,8 @@ use rayhunter::analysis::analyzer::AnalyzerConfig;
 use crate::error::RayhunterError;
 use crate::notifications::NotificationType;
 
+pub const WIFI_CREDS_PATH: &str = "/data/rayhunter/wifi-creds.conf";
+
 /// The structure of a valid rayhunter configuration
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(default)]
@@ -34,6 +36,8 @@ pub struct Config {
     pub analyzers: AnalyzerConfig,
     pub min_space_to_start_recording_mb: u64,
     pub min_space_to_continue_recording_mb: u64,
+    pub wifi_ssid: Option<String>,
+    pub wifi_password: Option<String>,
 }
 
 impl Default for Config {
@@ -51,6 +55,8 @@ impl Default for Config {
             enabled_notifications: vec![NotificationType::Warning, NotificationType::LowBattery],
             min_space_to_start_recording_mb: 1,
             min_space_to_continue_recording_mb: 1,
+            wifi_ssid: None,
+            wifi_password: None,
         }
     }
 }
@@ -59,12 +65,22 @@ pub async fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
 where
     P: AsRef<std::path::Path>,
 {
-    if let Ok(config_file) = tokio::fs::read_to_string(&path).await {
-        Ok(toml::from_str(&config_file).map_err(RayhunterError::ConfigFileParsingError)?)
+    let mut config = if let Ok(config_file) = tokio::fs::read_to_string(&path).await {
+        toml::from_str(&config_file).map_err(RayhunterError::ConfigFileParsingError)?
     } else {
         warn!("unable to read config file, using default config");
-        Ok(Config::default())
+        Config::default()
+    };
+
+    if let Ok(creds) = tokio::fs::read_to_string(WIFI_CREDS_PATH).await {
+        config.wifi_ssid = creds
+            .lines()
+            .find_map(|line| line.strip_prefix("ssid="))
+            .map(|s| s.to_string());
     }
+    config.wifi_password = None;
+
+    Ok(config)
 }
 
 pub struct Args {

daemon/src/server.rs

@@ -134,7 +134,9 @@ pub async fn serve_static(
 pub async fn get_config(
     State(state): State<Arc<ServerState>>,
 ) -> Result<Json<Config>, (StatusCode, String)> {
-    Ok(Json(state.config.clone()))
+    let mut config = state.config.clone();
+    config.wifi_password = None;
+    Ok(Json(config))
 }
 
 #[cfg_attr(feature = "apidocs", utoipa::path(
@@ -157,7 +159,11 @@ pub async fn set_config(
     State(state): State<Arc<ServerState>>,
     Json(config): Json<Config>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    let config_str = toml::to_string_pretty(&config).map_err(|err| {
+    let mut config_to_write = config.clone();
+    config_to_write.wifi_ssid = None;
+    config_to_write.wifi_password = None;
+
+    let config_str = toml::to_string_pretty(&config_to_write).map_err(|err| {
         (
             StatusCode::INTERNAL_SERVER_ERROR,
             format!("failed to serialize config as TOML: {err}"),
@@ -171,6 +177,8 @@ pub async fn set_config(
         )
     })?;
 
+    update_wifi_creds(&config).await;
+
     // Trigger daemon restart after writing config
     state.daemon_restart_token.cancel();
     Ok((
@@ -179,6 +187,50 @@ pub async fn set_config(
     ))
 }
 
+async fn update_wifi_creds(config: &Config) {
+    let has_ssid = config
+        .wifi_ssid
+        .as_ref()
+        .is_some_and(|s| !s.trim().is_empty());
+    let has_password = config
+        .wifi_password
+        .as_ref()
+        .is_some_and(|s| !s.trim().is_empty());
+
+    let creds_path = crate::config::WIFI_CREDS_PATH;
+
+    if !has_ssid {
+        if tokio::fs::metadata(creds_path).await.is_ok()
+            && let Err(e) = tokio::fs::remove_file(creds_path).await
+        {
+            warn!("failed to remove wifi credentials: {e}");
+        }
+    } else if has_password {
+        let contents = format!(
+            "ssid={}\npassword={}\n",
+            config.wifi_ssid.as_ref().unwrap(),
+            config.wifi_password.as_ref().unwrap()
+        );
+        if let Err(e) = write(creds_path, contents).await {
+            warn!("failed to write wifi credentials: {e}");
+        }
+    } else if let Ok(existing) = tokio::fs::read_to_string(creds_path).await {
+        let existing_password = existing
+            .lines()
+            .find_map(|line| line.strip_prefix("password="));
+        if let Some(password) = existing_password {
+            let contents = format!(
+                "ssid={}\npassword={}\n",
+                config.wifi_ssid.as_ref().unwrap(),
+                password
+            );
+            if let Err(e) = write(creds_path, contents).await {
+                warn!("failed to write wifi credentials: {e}");
+            }
+        }
+    }
+}
+
 #[cfg_attr(feature = "apidocs", utoipa::path(
     post,
     path = "/api/test-notification",

daemon/web/src/lib/components/ConfigForm.svelte

@@ -283,6 +283,48 @@
                     </div>
                 </div>
 
+                <div class="border-t pt-4 mt-6 space-y-3">
+                    <h3 class="text-lg font-semibold text-gray-800 mb-4">
+                        WiFi Client Mode (Orbic only)
+                    </h3>
+                    <p class="text-xs text-gray-500">
+                        Connect the device to an existing WiFi network for internet access (e.g.
+                        notifications). The hotspot AP stays running. Leave both fields empty to
+                        disable.
+                    </p>
+
+                    <div>
+                        <label for="wifi_ssid" class="block text-sm font-medium text-gray-700 mb-1">
+                            WiFi Network Name (SSID)
+                        </label>
+                        <input
+                            id="wifi_ssid"
+                            type="text"
+                            bind:value={config.wifi_ssid}
+                            placeholder="MyWiFiNetwork"
+                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                        />
+                    </div>
+
+                    <div>
+                        <label
+                            for="wifi_password"
+                            class="block text-sm font-medium text-gray-700 mb-1"
+                        >
+                            WiFi Password
+                        </label>
+                        <input
+                            id="wifi_password"
+                            type="password"
+                            bind:value={config.wifi_password}
+                            placeholder={config.wifi_ssid
+                                ? 'Leave blank to keep current password'
+                                : 'password'}
+                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                        />
+                    </div>
+                </div>
+
                 <div class="border-t pt-4 mt-6">
                     <h3 class="text-lg font-semibold text-gray-800 mb-4">
                         Analyzer Heuristic Settings

daemon/web/src/lib/utils.svelte.ts

@@ -27,6 +27,8 @@ export interface Config {
     analyzers: AnalyzerConfig;
     min_space_to_start_recording_mb: number;
     min_space_to_continue_recording_mb: number;
+    wifi_ssid: string | null;
+    wifi_password: string | null;
 }
 
 export async function req(method: string, url: string, json_body?: unknown): Promise<string> {