Files
javis_bot/app/src/features.rs
javis-bot 077db5031c feat(brain): botBrowser tool drives the bot's own Chrome over CDP
open, read, click (label or [n]), type (optionally Enter) and back; page content comes back fenced
as untrusted data; only http(s) addresses; no LLM call. Offered only when the app started the bot
browser (JARVIS_BROWSER_CDP) and the browser feature is on; meanwhile fetchWebPage, which has no
address guard, is not offered. Eval evals/test_bot_browser_tool.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 22:18:05 +09:00

138 lines
5.9 KiB
Rust

//! The brain's features and MCP servers (`app/src/admin.spec.md`, "Features and MCP servers"):
//! what the app writes into the brain's settings, and the MCP servers' environment values, which
//! are secrets and reach the worker only through its environment.
use serde_json::{json, Map, Value};
use crate::secrets::{Secrets, SecretsError};
use crate::settings::{FeatureSettings, McpServerSettings};
/// The worker's environment variable with the MCP servers' environment values
/// (`voice_worker/brain.py`, `MCP_ENV_VAR`).
pub const MCP_ENV_VAR: &str = "JARVIS_MCP_ENV";
/// The brain's built-in tools behind each feature switch (`jarvis/tools/registry.py`).
pub const FEATURE_TOOLS: &[(&str, &[&str])] = &[
("weather", &["getWeather"]),
("webSearch", &["webSearch", "fetchWebPage"]),
("meals", &["logMeal", "fetchMeals", "deleteMeal"]),
("browser", &["botBrowser"]),
];
/// The built-in tools of the features that are off.
pub fn disabled_tools(f: &FeatureSettings) -> Vec<&'static str> {
let on = |key: &str| match key {
"weather" => f.weather,
"webSearch" => f.web_search,
"browser" => f.browser,
_ => f.meals,
};
FEATURE_TOOLS.iter().filter(|(k, _)| !on(k)).flat_map(|(_, tools)| tools.iter().copied()).collect()
}
/// The brain's `mcps`: the enabled servers, without their environment values.
pub fn brain_mcps(servers: &[McpServerSettings]) -> Value {
Value::Object(servers.iter().filter(|s| s.enabled)
.map(|s| (s.name.clone(), json!({"transport": "stdio", "command": s.command, "args": s.args})))
.collect())
}
/// Where one environment value of a server is kept in the secrets.
pub fn secret_name(server: &str, var: &str) -> String {
format!("mcp:{server}:{var}")
}
/// `{server: {NAME: value}}` for the enabled servers, with the values that are stored.
pub fn mcp_env(secrets: &Secrets, servers: &[McpServerSettings]) -> Result<Value, SecretsError> {
let mut out = Map::new();
for s in servers.iter().filter(|s| s.enabled) {
let mut vars = Map::new();
for var in &s.env {
if let Some(v) = secrets.get(&secret_name(&s.name, var))? {
vars.insert(var.clone(), Value::String(v));
}
}
if !vars.is_empty() {
out.insert(s.name.clone(), Value::Object(vars));
}
}
Ok(Value::Object(out))
}
/// Which environment values are stored: `{server: {NAME: true|false}}` (never the values).
pub fn env_status(secrets: &Secrets, servers: &[McpServerSettings]) -> Result<Value, SecretsError> {
let names = secrets.names()?;
Ok(Value::Object(servers.iter().map(|s| {
let vars = s.env.iter().map(|v| (v.clone(), Value::Bool(names.contains(&secret_name(&s.name, v))))).collect();
(s.name.clone(), Value::Object(vars))
}).collect()))
}
/// Remove the stored values of servers and names no longer listed.
pub fn prune(secrets: &Secrets, servers: &[McpServerSettings]) -> Result<(), SecretsError> {
let keep: Vec<String> = servers.iter().flat_map(|s| s.env.iter().map(|v| secret_name(&s.name, v))).collect();
for name in secrets.names()? {
if name.starts_with("mcp:") && !keep.contains(&name) {
secrets.remove(&name)?;
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::datadir::temp_dir;
use crate::settings::parse_settings;
fn servers(v: Value) -> Vec<McpServerSettings> {
parse_settings(&json!({"mcpServers": v})).unwrap().mcp_servers
}
#[test]
fn the_feature_tools_are_the_brains_tool_names() {
let registry = std::fs::read_to_string(
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../src/jarvis/tools/registry.py")).unwrap();
for (_, tools) in FEATURE_TOOLS {
for t in *tools {
assert!(registry.contains(&format!("\"{t}\":")), "{t} is not a built-in tool");
}
}
}
#[test]
fn features_that_are_off_turn_their_tools_off() {
let all_on = FeatureSettings { weather: true, web_search: true, meals: true, collect: true, browser: true };
assert!(disabled_tools(&all_on).is_empty());
let off = disabled_tools(&FeatureSettings { weather: false, web_search: true, meals: false, collect: false, browser: false });
assert_eq!(off, vec!["getWeather", "logMeal", "fetchMeals", "deleteMeal", "botBrowser"]);
}
#[test]
fn only_enabled_servers_reach_the_brain_and_their_values_only_through_the_environment() {
let s = servers(json!([
{"name": "brave", "command": "npx", "args": ["-y", "brave"], "env": ["BRAVE_API_KEY", "UNSET"]},
{"name": "off", "command": "uvx", "env": ["K"], "enabled": false}]));
assert_eq!(brain_mcps(&s), json!({"brave": {"transport": "stdio", "command": "npx", "args": ["-y", "brave"]}}));
let secrets = Secrets::new(&temp_dir("mcpenv").join("secrets.dat"));
secrets.set(&secret_name("brave", "BRAVE_API_KEY"), "key-1").unwrap();
secrets.set(&secret_name("off", "K"), "key-2").unwrap();
assert_eq!(mcp_env(&secrets, &s).unwrap(), json!({"brave": {"BRAVE_API_KEY": "key-1"}}));
assert_eq!(env_status(&secrets, &s).unwrap(),
json!({"brave": {"BRAVE_API_KEY": true, "UNSET": false}, "off": {"K": true}}));
}
#[test]
fn values_of_removed_servers_and_names_are_deleted() {
let secrets = Secrets::new(&temp_dir("mcpprune").join("secrets.dat"));
secrets.set(crate::secrets::DISCORD_TOKEN, "tok").unwrap();
for (srv, var) in [("a", "K1"), ("a", "K2"), ("b", "K")] {
secrets.set(&secret_name(srv, var), "v").unwrap();
}
prune(&secrets, &servers(json!([{"name": "a", "command": "x", "env": ["K1"]}]))).unwrap();
let mut left = secrets.names().unwrap();
left.sort();
assert_eq!(left, vec![crate::secrets::DISCORD_TOKEN.to_string(), secret_name("a", "K1")]);
}
}