webterm_agent/models/
session.rs

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
use crate::models::activity::Activity;
use crate::models::agent_error::AgentError;
use crate::models::frontend::Frontend;
use crate::models::session_registry::SessionRegistry;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::{Mutex, RwLock};
use webterm_core::types::{ActivityId, SessionId};

pub struct Session {
    session_id: SessionId,
    activities: RwLock<HashMap<ActivityId, Arc<Activity>>>,
    current_frontend: Option<Arc<Mutex<Frontend>>>,
}

impl Session {
    pub fn new() -> Self {
        let session_id = SessionRegistry::next_session_id();

        Self {
            session_id,
            activities: RwLock::new(HashMap::new()),
            current_frontend: None,
        }
    }

    pub fn session_id(&self) -> SessionId {
        self.session_id
    }

    pub fn set_current_frontend(&mut self, frontend: Arc<Mutex<Frontend>>) {
        self.current_frontend = Some(frontend);
    }

    pub fn current_frontend(&self) -> Result<Arc<Mutex<Frontend>>, AgentError> {
        Ok(self
            .current_frontend
            .as_ref()
            .ok_or(AgentError::RuntimeError(
                "Current frontend is not set".to_string(),
            ))?
            .clone())
    }

    pub async fn get_activity(
        &self,
        activity_id: &ActivityId,
    ) -> Result<Arc<Activity>, AgentError> {
        let activity = self
            .activities
            .read()
            .await
            .get(activity_id)
            .ok_or(AgentError::RuntimeError(format!(
                "Activity {:?} not found",
                activity_id
            )))?
            .clone();

        Ok(activity)
    }

    pub async fn create_terminal_activity(&self) -> Result<Arc<Activity>, AgentError> {
        let activity = Activity::create_pty(self.session_id).await?;
        self.add_activity(activity.clone()).await;
        Ok(activity)
    }

    pub async fn add_activity(&self, activity: Arc<Activity>) {
        self.activities
            .write()
            .await
            .insert(activity.activity_id(), activity.clone());
    }
}