hippox-drivers 0.3.1

🦛All indivisible atomic driver units in Hippox.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! WiFi import config skill - import WiFi configuration from file

use anyhow::Result;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::fs::File;
use std::io::Read;

use super::common::connect_wifi;
use crate::DriverCallback;
use crate::DriverContext;
use crate::{
    DriverCategory,
    types::{Driver, DriverParameter},
};
#[derive(Debug)]
pub struct WifiImportConfigDriver;

#[async_trait::async_trait]
impl Driver for WifiImportConfigDriver {
    fn name(&self) -> &str {
        "wifi_import_config"
    }

    fn description(&self) -> &str {
        "Import WiFi configuration from a backup file to restore saved networks"
    }

    fn usage_hint(&self) -> &str {
        "Use this skill to restore WiFi settings from a previously exported backup file."
    }

    fn parameters(&self) -> Vec<DriverParameter> {
        vec![
            DriverParameter {
                name: "file_path".to_string(),
                param_type: "string".to_string(),
                description: "Path to the configuration file to import".to_string(),
                required: true,
                default: None,
                example: Some(Value::String("./wifi_backup.json".to_string())),
                enum_values: None,
            },
            DriverParameter {
                name: "auto_connect".to_string(),
                param_type: "boolean".to_string(),
                description:
                    "Automatically connect to the best network after import (default: false)"
                        .to_string(),
                required: false,
                default: Some(Value::Bool(false)),
                example: Some(Value::Bool(true)),
                enum_values: None,
            },
        ]
    }

    fn example_call(&self) -> Value {
        json!({
            "action": "wifi_import_config",
            "parameters": {
                "file_path": "./wifi_backup.json",
                "auto_connect": false
            }
        })
    }

    fn example_output(&self) -> String {
        "Imported 3 WiFi networks from: ./wifi_backup.json".to_string()
    }

    fn category(&self) -> DriverCategory {
        DriverCategory::Wifi
    }

    async fn execute(
        &self,
        parameters: &HashMap<String, Value>,
        callback: Option<&dyn DriverCallback>,
        context: Option<&DriverContext>,
    ) -> Result<String> {
        let file_path = parameters
            .get("file_path")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow::anyhow!("Missing 'file_path' parameter"))?;
        let auto_connect = parameters
            .get("auto_connect")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        // Read and parse the backup file
        let mut file = File::open(file_path)?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        let import_data: serde_json::Value = serde_json::from_str(&contents)?;
        let networks = import_data["networks"].as_array().ok_or_else(|| {
            anyhow::anyhow!("Invalid backup file format: missing 'networks' array")
        })?;
        let mut imported_count = 0;
        let mut best_network: Option<String> = None;
        let mut best_signal = -100;
        for network in networks {
            let ssid = network["ssid"]
                .as_str()
                .ok_or_else(|| anyhow::anyhow!("Network missing 'ssid' field"))?;
            let password = network["password"].as_str();
            // Import the network
            connect_wifi(ssid, password)?;
            imported_count += 1;
            // Check signal strength for auto-connect decision
            if auto_connect {
                tokio::time::sleep(std::time::Duration::from_millis(500)).await;
                let status = super::common::get_wifi_status()?;
                if let Some(signal) = status.signal_strength {
                    if signal > best_signal {
                        best_signal = signal;
                        best_network = Some(ssid.to_string());
                    }
                }
            }
        }
        // Auto-connect to the best network if requested
        let auto_connect_msg = if auto_connect {
            if let Some(ref network) = best_network {
                connect_wifi(network, None)?;
                tokio::time::sleep(std::time::Duration::from_secs(2)).await;
                format!(" (auto-connected to: {})", network)
            } else {
                String::new()
            }
        } else {
            String::new()
        };
        Ok(format!(
            "Imported {} WiFi networks from: {}{}",
            imported_count, file_path, auto_connect_msg
        ))
    }
}