boxwren 0.2.3

Local-first WebAssembly sandbox for untrusted agent code. Deny-by-default limits, capability grants, and a kill switch.
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

//! Captured guest stdio. Writes past the cap are dropped and flagged.

use std::io;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll};

use tokio::io::AsyncWrite;
use wasmtime_wasi::cli::{IsTerminal, StdoutStream};

#[derive(Clone)]
pub(crate) struct Capture {
    inner: Arc<Mutex<CaptureBuf>>,
}

struct CaptureBuf {
    bytes: Vec<u8>,
    cap: usize,
    truncated: bool,
}

impl Capture {
    pub(crate) fn new(cap: usize) -> Self {
        Self {
            inner: Arc::new(Mutex::new(CaptureBuf {
                bytes: Vec::new(),
                cap,
                truncated: false,
            })),
        }
    }

    pub(crate) fn text(&self) -> (String, bool) {
        let guard = self
            .inner
            .lock()
            .unwrap_or_else(|poison| poison.into_inner());
        (
            String::from_utf8_lossy(&guard.bytes).into_owned(),
            guard.truncated,
        )
    }
}

struct CaptureWriter {
    inner: Arc<Mutex<CaptureBuf>>,
}

impl AsyncWrite for CaptureWriter {
    fn poll_write(
        self: Pin<&mut Self>,
        _cx: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<io::Result<usize>> {
        let mut guard = self
            .inner
            .lock()
            .unwrap_or_else(|poison| poison.into_inner());
        let room = guard.cap.saturating_sub(guard.bytes.len());
        if room == 0 {
            guard.truncated = true;
        } else {
            let n = buf.len().min(room);
            guard.bytes.extend_from_slice(&buf[..n]);
            if n < buf.len() {
                guard.truncated = true;
            }
        }
        // Report the full length so the guest is not killed for being noisy.
        // Bytes past the cap are discarded and `truncated` is set.
        Poll::Ready(Ok(buf.len()))
    }

    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }

    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }
}

impl IsTerminal for Capture {
    fn is_terminal(&self) -> bool {
        false
    }
}

impl StdoutStream for Capture {
    fn async_stream(&self) -> Box<dyn AsyncWrite + Send + Sync> {
        Box::new(CaptureWriter {
            inner: Arc::clone(&self.inner),
        })
    }
}