qinstagram 0.1.1

Enterprise-grade IG Private API Architecture & Protocol Engineering toolkit with 100% Async-GraphQL & Websocket integration.
Documentation 
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

use reqwest_cookie_store::CookieStoreMutex;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use tokio::fs;

use crate::error::{InstagramError, Result};
use crate::transport::device::DeviceInfo;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppState {
    pub device: DeviceInfo,
    pub cookies: String,
}

pub struct SessionManager {
    pub username: String,
    pub session_dir: PathBuf,
}

impl SessionManager {
    pub async fn new(username: &str) -> Result<Self> {
        let mut home_dir = dirs::home_dir().ok_or_else(|| InstagramError::Unknown("Cannot find home directory".to_string()))?;
        home_dir.push(".instagram-cli");
        home_dir.push("users");
        home_dir.push(username);
        
        if !home_dir.exists() {
            fs::create_dir_all(&home_dir).await.map_err(InstagramError::IoError)?;
        }
        
        Ok(Self {
            username: username.to_string(),
            session_dir: home_dir,
        })
    }
    
    pub fn session_file_path(&self) -> PathBuf {
        let mut path = self.session_dir.clone();
        path.push("session.rust.json");
        path
    }

    pub async fn load_state(&self) -> Result<Option<AppState>> {
        let path = self.session_file_path();
        if path.exists() {
            let content = fs::read_to_string(&path).await.map_err(InstagramError::IoError)?;
            let state: AppState = serde_json::from_str(&content).map_err(InstagramError::SerdeError)?;
            Ok(Some(state))
        } else {
            Ok(None)
        }
    }

    pub async fn save_state(&self, device: &DeviceInfo, cookie_store: &CookieStoreMutex) -> Result<()> {
        let path = self.session_file_path();
        let mut buffer = Vec::new();
        {
            #[allow(deprecated)]
            let guard = cookie_store.lock().map_err(|_| InstagramError::Unknown("Failed to lock cookie store".into()))?;
            #[allow(deprecated)]
            guard.save_json(&mut buffer).map_err(|e| InstagramError::Unknown(e.to_string()))?;
        }
        let cookies_str = String::from_utf8(buffer).map_err(|e| InstagramError::Unknown(e.to_string()))?;
        
        let state = AppState {
            device: device.clone(),
            cookies: cookies_str,
        };
        
        let content = serde_json::to_string_pretty(&state).map_err(InstagramError::SerdeError)?;
        fs::write(&path, content).await.map_err(InstagramError::IoError)?;
        Ok(())
    }

    pub async fn cleanup_sessions() -> Result<()> {
        let mut home_dir = dirs::home_dir().ok_or_else(|| InstagramError::Unknown("Cannot find home directory".to_string()))?;
        home_dir.push(".instagram-cli");
        home_dir.push("users");
        
        if home_dir.exists() {
            let mut entries = fs::read_dir(home_dir).await.map_err(InstagramError::IoError)?;
            while let Ok(Some(entry)) = entries.next_entry().await {
                let path = entry.path();
                if path.is_dir() {
                    let session_file = path.join("session.rust.json");
                    if session_file.exists() {
                        let _ = fs::remove_file(session_file).await;
                    }
                }
            }
        }
        Ok(())
    }

    pub async fn delete_session(&self) -> Result<()> {
        let path = self.session_file_path();
        if path.exists() {
            fs::remove_file(path).await.map_err(InstagramError::IoError)?;
        }
        Ok(())
    }
}