do-memory-mcp 0.1.26

Model Context Protocol (MCP) server with secure code execution sandbox for AI agents
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

//! WASM sandbox configuration

use anyhow::Result;
#[cfg(feature = "wasm-rquickjs")]
use rquickjs::Runtime;
use std::time::{Duration, Instant};

/// WASM sandbox configuration
#[derive(Debug, Clone)]
pub struct WasmConfig {
    /// Maximum execution time per script
    pub max_execution_time: Duration,
    /// Maximum memory usage per script (in MB)
    pub max_memory_mb: usize,
    /// Whether to allow console output
    pub allow_console: bool,
    /// Maximum number of runtimes in pool
    pub max_pool_size: usize,
    /// How long a runtime can be idle before cleanup
    pub runtime_idle_timeout: Duration,
}

impl Default for WasmConfig {
    fn default() -> Self {
        Self {
            max_execution_time: Duration::from_secs(5),
            max_memory_mb: 64,
            allow_console: true,
            max_pool_size: 10,
            runtime_idle_timeout: Duration::from_secs(60),
        }
    }
}

impl WasmConfig {
    /// Create a restrictive configuration for untrusted code
    pub fn restrictive() -> Self {
        Self {
            max_execution_time: Duration::from_secs(2),
            max_memory_mb: 32,
            allow_console: false,
            max_pool_size: 5,
            runtime_idle_timeout: Duration::from_secs(30),
        }
    }

    /// Create a permissive configuration for trusted code
    pub fn permissive() -> Self {
        Self {
            max_execution_time: Duration::from_secs(30),
            max_memory_mb: 128,
            allow_console: true,
            max_pool_size: 20,
            runtime_idle_timeout: Duration::from_secs(300),
        }
    }
}

/// Pooled WASM runtime for efficient reuse
#[cfg(feature = "wasm-rquickjs")]
pub(super) struct PooledRuntime {
    pub runtime: Runtime,
    pub last_used: Instant,
}

#[cfg(feature = "wasm-rquickjs")]
impl std::fmt::Debug for PooledRuntime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("PooledRuntime")
            .field("last_used", &self.last_used)
            .finish()
    }
}

#[cfg(feature = "wasm-rquickjs")]
impl PooledRuntime {
    pub fn new(_config: &WasmConfig) -> Result<Self> {
        let runtime = Runtime::new()?;

        Ok(Self {
            runtime,
            last_used: Instant::now(),
        })
    }

    pub fn is_expired(&self, timeout: Duration) -> bool {
        self.last_used.elapsed() > timeout
    }

    pub fn touch(&mut self) {
        self.last_used = Instant::now();
    }
}