Struct SessionManager 

pub struct SessionManager { /* private fields */ }

AI-optimized session manager for creating and managing multiple terminal sessions.

The SessionManager provides a centralized way to create, track, and manage AI-enhanced terminal sessions. It includes automatic cleanup, session restoration, and efficient resource management.

Features

• Session Pooling: Efficient management of multiple concurrent sessions
• Automatic Cleanup: Garbage collection of terminated sessions
• Session Restoration: Restore sessions from persistent storage
• Resource Management: Automatic cleanup and memory management

Examples

Basic Session Management

use ai_session::{SessionManager, SessionConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Create multiple sessions
    let session1 = manager.create_session().await?;
    let session2 = manager.create_session().await?;
     
    session1.start().await?;
    session2.start().await?;
     
    // List all active sessions
    let session_ids = manager.list_sessions();
    println!("Active sessions: {}", session_ids.len());
     
    // Clean up
    manager.remove_session(&session1.id).await?;
    manager.remove_session(&session2.id).await?;
     
    Ok(())
}

Custom Configuration

use ai_session::{SessionManager, SessionConfig, ContextConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Configure for AI development agent
    let mut config = SessionConfig::default();
    config.enable_ai_features = true;
    config.agent_role = Some("backend-developer".to_string());
    config.working_directory = "/project/backend".into();
    config.context_config = ContextConfig {
        max_tokens: 8192,
        compression_threshold: 0.8,
    };
     
    let session = manager.create_session_with_config(config).await?;
    session.start().await?;
     
    // Session is optimized for AI backend development
    Ok(())
}

Session Persistence

use ai_session::{SessionManager, SessionConfig, SessionId};
use chrono::Utc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let manager = SessionManager::new();
     
    // Create session
    let config = SessionConfig::default();
    let session = manager.create_session_with_config(config.clone()).await?;
    let session_id = session.id.clone();
    let created_at = session.created_at;
     
    // Later, restore the session
    let restored = manager.restore_session(session_id, config, created_at).await?;
    restored.start().await?;
     
    Ok(())
}

Implementations

impl SessionManager

pub fn new() -> Self

Create a new session manager

pub async fn create_session(&self) -> Result<Arc<AISession>>

Create a new session with default config

pub async fn create_session_with_config( &self, config: SessionConfig, ) -> Result<Arc<AISession>>

Create a new session with custom config

pub async fn restore_session( &self, id: SessionId, config: SessionConfig, created_at: DateTime<Utc>, ) -> Result<Arc<AISession>>

Restore a session with a specific ID (for persistence)

pub fn get_session(&self, id: &SessionId) -> Option<Arc<AISession>>

Get a session by ID

pub fn list_sessions(&self) -> Vec<SessionId>

List all active sessions

pub fn list_session_refs(&self) -> Vec<Arc<AISession>>

List all active session references

pub async fn remove_session(&self, id: &SessionId) -> Result<()>

Remove a session

pub async fn cleanup_terminated(&self) -> Result<usize>

Clean up terminated sessions

pub fn find_session_by_name(&self, name: &str) -> Option<Arc<AISession>>

Find a session by its name (exact match)

Arguments

• name - The exact name to search for

Returns

The session if found, None otherwise

pub fn list_sessions_by_prefix(&self, prefix: &str) -> Vec<Arc<AISession>>

Find sessions with names matching a prefix

Arguments

• prefix - The prefix to match against session names

Returns

List of sessions whose names start with the given prefix

pub fn list_sessions_detailed(&self) -> Vec<SessionInfo>

List all sessions with detailed information (snapshot, no locking required)

Returns a vector of SessionInfo containing summary information about all active sessions. This is more efficient than listing sessions and then querying each one individually.

Trait Implementations

impl Default for SessionManager

fn default() -> Self

Returns the “default value” for a type.