rigspark-runtime 3.0.8

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use serde::Serialize;
use serde_json::Value;
use std::collections::HashSet;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum ToolRisk {
    ReadOnly,
    ProcessNetwork,
    WorkspaceMutation,
    Unknown,
}

pub fn classify(name: &str, description: &str) -> ToolRisk {
    let mut expanded = String::new();
    let mut lower = false;
    for character in format!("{name} {description}").chars() {
        if lower && character.is_ascii_uppercase() {
            expanded.push(' ');
        }
        lower = character.is_ascii_lowercase();
        expanded.push(character.to_ascii_lowercase());
    }
    let tokens: HashSet<_> = expanded
        .split(|character: char| !character.is_ascii_alphanumeric())
        .collect();
    for (risk, words) in [
        (
            ToolRisk::WorkspaceMutation,
            "write create delete remove edit apply patch move rename mkdir rmdir chmod put update insert drop",
        ),
        (
            ToolRisk::ProcessNetwork,
            "exec execute run shell command spawn fetch http https request curl wget download upload network socket ssh",
        ),
        (
            ToolRisk::ReadOnly,
            "read get list search find show view cat status diff log query describe inspect lookup",
        ),
    ] {
        if words.split(' ').any(|word| tokens.contains(word)) {
            return risk;
        }
    }
    ToolRisk::Unknown
}
pub fn redact_arguments(value: &Value) -> Value {
    fn redact(value: &Value, depth: usize) -> Value {
        if depth > 4 {
            return Value::String("[...]".into());
        }
        match value {
            Value::String(text) if text.encode_utf16().count() > 256 => Value::String(format!(
                "{}... [{} chars]",
                text.chars().take(64).collect::<String>(),
                text.encode_utf16().count()
            )),
            Value::Array(values) => Value::Array(
                values
                    .iter()
                    .take(20)
                    .map(|value| redact(value, depth + 1))
                    .collect(),
            ),
            Value::Object(values) => Value::Object(
                values
                    .iter()
                    .take(128)
                    .map(|(key, value)| {
                        let lower = key.to_lowercase();
                        let secret = [
                            "token",
                            "secret",
                            "key",
                            "password",
                            "passwd",
                            "pwd",
                            "auth",
                            "credential",
                            "cookie",
                            "session",
                            "bearer",
                        ]
                        .iter()
                        .any(|word| lower.contains(word));
                        (
                            key.clone(),
                            if secret {
                                Value::String("[redacted]".into())
                            } else {
                                redact(value, depth + 1)
                            },
                        )
                    })
                    .collect(),
            ),
            _ => value.clone(),
        }
    }
    redact(value, 0)
}
pub(crate) fn serialize_arguments<Serializer: serde::Serializer>(
    value: &Value,
    serializer: Serializer,
) -> Result<Serializer::Ok, Serializer::Error> {
    redact_arguments(value).serialize(serializer)
}
#[derive(Debug, Serialize)]
pub struct ResultPreview {
    pub text: String,
    pub truncated: bool,
}
pub fn redact_result(text: &str) -> ResultPreview {
    let mut masked = String::new();
    for part in text.split_inclusive(|character: char| {
        !character.is_ascii_alphanumeric() && !['_', '-'].contains(&character)
    }) {
        let token = part.trim_end_matches(|character: char| {
            !character.is_ascii_alphanumeric() && !['_', '-'].contains(&character)
        });
        if token.len() >= 24
            && token.bytes().any(|byte| byte.is_ascii_alphabetic())
            && token.bytes().any(|byte| byte.is_ascii_digit())
        {
            masked.push_str("[redacted]");
            masked.push_str(&part[token.len()..]);
        } else {
            masked.push_str(part);
        }
        if masked.encode_utf16().count() > 2048 {
            return ResultPreview {
                text: format!("{}...", crate::sessions::cap(&masked, 2048)),
                truncated: true,
            };
        }
    }
    ResultPreview {
        text: masked,
        truncated: false,
    }
}

#[derive(Default)]
pub struct SessionGrants {
    session: String,
    workspace: Option<String>,
    grants: HashSet<String>,
}
impl SessionGrants {
    pub fn select(&mut self, session: &str, workspace: Option<&str>) {
        if self.session != session || self.workspace.as_deref() != workspace {
            self.grants.clear();
            self.session = session.into();
            self.workspace = workspace.map(str::to_owned);
        }
    }
    pub fn clear(&mut self) {
        self.grants.clear();
    }
    pub(crate) fn grant(&mut self, key: String) -> bool {
        if self.session.is_empty() || self.grants.len() >= 1024 {
            return false;
        }
        self.grants.insert(key);
        true
    }
    pub(crate) fn allows(&self, key: &str) -> bool {
        !self.session.is_empty() && self.grants.contains(key)
    }
}