Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
58 changes: 55 additions & 3 deletions crates/bezel-bridle/src/calls.rs
Original file line number Diff line number Diff line change
Expand Up @@ -170,7 +170,7 @@ fn decide_json(mode: &str, tools: &[Tool], winner: &str, confidence: f64, probab
mapped = "stop";
code_deny = true;
} else if let Some(tool) = picked {
match guard_effect(tool.effect) {
match guard_kind(tool.effect) {
Guard::Missing => {
reason = "effect_missing";
code = Some("F456");
Expand Down Expand Up @@ -385,11 +385,63 @@ fn effect_class(effect: &str) -> Option<&str> {
if known_effect(effect) { Some(effect) } else { None }
}

fn effect_allows(effect: &str) -> bool {
pub fn effect_allows(effect: &str) -> bool {
matches!(effect, "read" | "write" | "filesystem" | "network" | "external")
}

fn guard_effect(effect: &str) -> Guard {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EffectGuard {
pub allow: bool,
pub code: Option<&'static str>,
pub reason: &'static str,
}

pub fn guard_effect(effect: &str) -> EffectGuard {
if effect.is_empty() {
return EffectGuard {
allow: false,
code: Some("F456"),
reason: "effect_missing",
};
}
if !known_effect(effect) {
return EffectGuard {
allow: false,
code: Some("F456"),
reason: "effect_invalid",
};
}
if effect_allows(effect) {
return EffectGuard {
allow: true,
code: None,
reason: "obvious_effect",
};
}
EffectGuard {
allow: false,
code: Some("F454"),
reason: "effect_deny",
}
}

pub fn stated_keeps_optional_arg(noul: f64) -> bool {
noul > 0.5
}

pub fn rank_names<'a>(rows: &[(&'a str, f64)], limit: usize) -> Vec<&'a str> {
let mut rows: Vec<(&str, f64)> = rows.to_vec();
rows.sort_by(|left, right| {
right
.1
.partial_cmp(&left.1)
.unwrap_or(std::cmp::Ordering::Equal)
.then_with(|| left.0.cmp(right.0))
});
rows.into_iter().take(limit).map(|(name, _)| name).collect()
}

fn guard_kind(effect: &str) -> Guard {
if effect.is_empty() {
Guard::Missing
} else if !known_effect(effect) {
Expand Down
61 changes: 61 additions & 0 deletions crates/bezel-bridle/src/catalog.rs
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,67 @@ pub fn tiny_catalog_json() -> String {
)
}

/// `buildGateState`: tiny catalog on the state, secret keys and full schemas dropped.
pub struct GateInput<'a> {
pub intent: &'a str,
pub typesafe_api_key: Option<&'a str>,
pub api_key: Option<&'a str>,
pub schema: Option<&'a str>,
pub loop_stop_policy_version: &'a str,
pub secret: &'a str,
}

pub fn build_gate_state(input: &GateInput<'_>) -> String {
if secret_key("TYPESAFE_API_KEY") {
let _ = input.typesafe_api_key;
}
if secret_key("apiKey") {
let _ = input.api_key;
}
let _ = input.schema;
let intent = redact_secret(input.intent, input.secret);
let catalog = tiny_catalog_json();
format!(
r#"{{"intent":{},"loopStopPolicy":{{"version":{}}},"catalog":{catalog}}}"#,
json_string(&intent),
json_string(input.loop_stop_policy_version),
)
}

fn secret_key(key: &str) -> bool {
let lower = key.to_ascii_lowercase();
lower.contains("api_key")
|| lower.contains("apikey")
|| lower.contains("api-key")
|| lower.contains("secret")
|| lower.contains("token")
|| lower.contains("authorization")
|| lower.contains("password")
|| lower.contains("credential")
}

fn redact_secret(text: &str, secret: &str) -> String {
if secret.is_empty() {
text.to_string()
} else {
text.replace(secret, "[redacted]")
}
}

fn json_string(value: &str) -> String {
let mut out = String::from("\"");
for ch in value.chars() {
match ch {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
other => out.push(other),
}
}
out.push('"');
out
}

pub fn schema_dump_json(tool_name: &str) -> String {
let name = tool_name;
let Some((class_id, policy_id)) = match_pretool_class(name) else {
Expand Down
209 changes: 168 additions & 41 deletions crates/bezel-bridle/src/cli.rs
Original file line number Diff line number Diff line change
Expand Up @@ -60,14 +60,28 @@ pub fn fixture_client() -> Client {
construct_client(recorded_dir())
}

#[cfg(test)]
pub(crate) fn test_env_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
LOCK.lock().unwrap_or_else(|poison| poison.into_inner())
}

pub fn run(args: &[String]) -> (i32, String) {
if args.first().map(String::as_str) == Some("--version") && args.len() == 1 {
return (0, format!("bezel-bridle {}\n", env!("CARGO_PKG_VERSION")));
}
if args.first().map(String::as_str) == Some("hook") {
return hook_verdict();
let mut stdin = String::new();
let _ = std::io::Read::read_to_string(&mut std::io::stdin(), &mut stdin);
return hook_cli(&stdin);
}
if args.first().map(String::as_str) == Some("smoke") {
return (0, format!("{}\n", crate::harness::smoke_report()));
}
if args.iter().any(|arg| arg == "--catalog") {
if args.first().map(String::as_str) == Some("config") {
return (0, format!("{}\n", crate::harness::harness_config()));
}
if args.first().map(String::as_str) == Some("catalog") || args.iter().any(|arg| arg == "--catalog") {
return (0, format!("{}\n", tiny_catalog_json()));
}
if let Some(index) = args.iter().position(|arg| arg == "--schema" || arg == "--schema-dump") {
Expand All @@ -91,6 +105,104 @@ pub fn run(args: &[String]) -> (i32, String) {
mod tests {
use super::run;

#[test]
fn hook_cli_matches_hook_command() {
let _lock = env_lock();
let _env = EnvSet::apply(&[("JEV_ROUTER", None)]);
let stdin = r#"{"tool_name":"Bash","tool_input":{"command":"npm test"}}"#;
let (code, out) = super::hook_cli(stdin);
let owned: Vec<(String, String)> = std::env::vars().collect();
let pairs: Vec<(&str, &str)> = owned.iter().map(|(key, value)| (key.as_str(), value.as_str())).collect();
let (expect_code, expect) = crate::harness::hook_command(stdin, &pairs);
assert_eq!(code, expect_code);
assert_eq!(out, expect);
assert!(out.contains("\"decision\":\"defer\"") || out.contains("\"decision\":\"deny\""));
assert!(!out.contains("\"decision\":\"allow\""));
}

/// grok-build-harness spawns JEV_ROUTER for a matched hook and skips it on bypass.
#[test]
fn hook_cli_spawns_router_stop_and_skips_bypass() {
let _lock = env_lock();
let dir = std::env::temp_dir().join(format!("bezel-hook-spawn-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let router = dir.join("router");
let garbage = dir.join("garbage");
let argv = dir.join("argv");
let called = dir.join("called");
std::fs::write(
&router,
"#!/bin/sh\nif [ \"${HARNESS_MARK:-}\" = \"poison\" ]; then\n : > \"${HARNESS_CALLED_FILE:?}\"\n exit 99\nfi\nprintf '%s\\n' \"$*\" > \"${HARNESS_ARGV_LOG:-/dev/null}\"\nprintf '%s\\n' '{\"ok\":true,\"mode\":\"active\",\"choice\":\"stop\",\"gate\":\"hold\",\"blocked\":true,\"exec\":false,\"bypass\":false}'\n",
)
.unwrap();
std::fs::write(&garbage, "#!/bin/sh\nprintf '%s\\n' 'not-json'\n").unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&router, std::fs::Permissions::from_mode(0o755)).unwrap();
std::fs::set_permissions(&garbage, std::fs::Permissions::from_mode(0o755)).unwrap();
}
let event = r#"{"hookEventName":"PreToolUse","toolName":"Bash","toolInput":{"command":"npm test"}}"#;
let _env = EnvSet::apply(&[
("JEV_ROUTER", Some(router.to_str().unwrap())),
("JEV_BYPASS", Some("")),
("JEV_MODE", Some("active")),
("HARNESS_ARGV_LOG", Some(argv.to_str().unwrap())),
("HARNESS_MARK", None),
("HARNESS_CALLED_FILE", None),
("TYPESAFE_API_KEY", None),
]);
std::fs::write(&argv, "").unwrap();
let (code, out) = super::hook_cli(event);
assert_eq!(code, 2, "{out}");
assert!(out.contains("\"decision\":\"deny\""), "{out}");
assert!(out.contains("policy=omapi-loop-stop-policy@1"), "{out}");
let logged = std::fs::read_to_string(&argv).unwrap();
assert!(logged.contains("--tool-name"), "{logged}");
assert!(logged.contains("Bash"), "{logged}");
assert!(logged.contains("--tool-input"), "{logged}");
assert!(logged.contains("npm test"), "{logged}");

set_env("JEV_BYPASS", Some("1"));
set_env("HARNESS_MARK", Some("poison"));
set_env("HARNESS_CALLED_FILE", Some(called.to_str().unwrap()));
let (code, out) = super::hook_cli(event);
assert_eq!(code, 0, "{out}");
assert!(out.contains("\"decision\":\"defer\"") && out.contains("\"reason\":\"bypass\""), "{out}");
assert!(!called.exists(), "bypass must not call the router");

set_env("JEV_BYPASS", Some(""));
set_env("HARNESS_MARK", None);
set_env("JEV_MODE", Some("active"));
set_env("JEV_ROUTER", Some(garbage.to_str().unwrap()));
let (code, out) = super::hook_cli(event);
assert_eq!(code, 2, "{out}");
assert!(out.contains("\"reason\":\"jev uncertain\""), "{out}");

set_env("JEV_MODE", Some("shadow"));
let (code, out) = super::hook_cli(event);
assert_eq!(code, 0, "{out}");
assert!(out.contains("\"decision\":\"defer\"") && out.contains("\"reason\":\"shadow\""), "{out}");

set_env("JEV_ROUTER", None);
set_env("JEV_MODE", Some("shadow"));
set_env("JEV_BYPASS", Some(""));
let (code, out) = super::hook_cli("");
assert_eq!(code, 0, "{out}");
assert!(out.contains("\"decision\":\"defer\""), "{out}");
let oma_on = ["oma", "on"].join(" ");
let omapi_mark = ["omapi", "mark"].join("-");
let bezel_mark = ["bezel", "mark"].join("-");
assert!(!out.contains(&oma_on) && !out.contains(&omapi_mark) && !out.contains(&bezel_mark));

let (code, out) = run(&["catalog".into()]);
assert_eq!(code, 0, "{out}");
assert!(out.contains("\"kind\":\"tiny\""), "{out}");
assert!(!out.contains(&oma_on) && !out.contains(&omapi_mark) && !out.contains(&bezel_mark));
let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn version_matches_package() {
let (code, out) = run(&["--version".into()]);
Expand Down Expand Up @@ -255,8 +367,7 @@ mod tests {
}

fn env_lock() -> std::sync::MutexGuard<'static, ()> {
static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
LOCK.lock().unwrap_or_else(|poison| poison.into_inner())
super::test_env_lock()
}

fn set_env(key: &str, value: Option<&str>) {
Expand Down Expand Up @@ -295,45 +406,61 @@ mod tests {
}
}

/// `jev-router hook` with no key. Same bytes as the JavaScript shadow verdict.
fn hook_verdict() -> (i32, String) {
let active = std::env::var("JEV_MODE")
.map(|value| value.eq_ignore_ascii_case("active"))
.unwrap_or(false);
let repo = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
let gathered = gather(&GatherOpts {
repo,
base: String::new(),
diff_file: None,
diff_text: None,
write: None,
/// `jev-router hook` reads stdin and uses the harness command.
fn hook_cli(stdin: &str) -> (i32, String) {
let owned: Vec<(String, String)> = std::env::vars().collect();
let pairs: Vec<(&str, &str)> = owned.iter().map(|(key, value)| (key.as_str(), value.as_str())).collect();
let modes = crate::harness::modes_from_env(&pairs);
let event = crate::harness::parse_hook_event(stdin).unwrap_or(crate::harness::HookEvent {
tool_name: String::new(),
command: String::new(),
});
let present = if gathered.diff.present { "true" } else { "false" };
let caps = present;
let available = if gathered.diff.present {
"\"check\",\"review\""
} else {
""
};
let catalog = tiny_catalog_json();
let policy = crate::policy::LOOP_STOP_POLICY_ID;
let route = crate::policy::ROUTING_POLICY_ID;
let facts = format!(
r#"{{"diffPresent":{present},"diffSource":"{}","available":[{available}],"capabilities":{{"check":{caps},"review":{caps}}}}}"#,
gathered.diff.source,
);
if !active {
let body = format!(
r#"{{"ok":true,"mode":"shadow","bypass":false,"missingKey":true,"choice":"unclassified","gate":"auto","blocked":false,"exec":true,"hitl":false,"autoRetry":false,"autoPromote":false,"intent":"hook","stepDigest":"","loop":{{"policy":"{policy}","selected":"unclassified","outcome":"cannot_tell","reason":"missing_key","hitl":false,"autoRetry":false,"autoPromote":false,"shadow":true,"blocked":false}},"workflow":{{"choice":"unclassified","outcome":"cannot_tell","reason":"missing_key","shadow":true,"blocked":false}},"facts":{facts},"routingPolicy":"{route}","loopStopPolicy":"{policy}","catalog":{catalog}}}"#
);
return (0, format!("{body}\n"));
let matched = !event.tool_name.is_empty()
&& crate::policy::pretool_stamp(&event.tool_name).is_some_and(|stamp| stamp.matched);
let router = std::env::var("JEV_ROUTER").unwrap_or_default();
if modes.bypass || !matched || router.is_empty() {
return crate::harness::hook_command(stdin, &pairs);
}
let _facts = facts;
let body = format!(
r#"{{"ok":false,"mode":"active","missingKey":true,"choice":"escalate","gate":"hold","blocked":true,"exec":false,"hitl":true,"autoRetry":false,"autoPromote":false,"intent":"hook","stepDigest":"","loop":{{"policy":"{policy}","selected":"cannot_tell","outcome":"cannot_tell","reason":"missing_key","confidence":0,"selectedProb":0,"margin":0,"hitl":true,"autoRetry":false,"autoPromote":false}},"catalog":{catalog}}}"#
);
let _route = route;
(2, format!("{body}\n"))
let verdict = spawn_router(&router, &event);
let decision = crate::harness::decide_hook(&event, &modes, verdict.as_ref());
(decision.exit_code, crate::harness::hook_stdout(&decision))
}

fn spawn_router(bin: &str, event: &crate::harness::HookEvent) -> Option<crate::policy::GateVerdict> {
let mut args = vec![
"--tool-name".to_string(),
event.tool_name.clone(),
"--intent".to_string(),
event.tool_name.clone(),
];
if !event.command.is_empty() {
args.push("--tool-input".to_string());
args.push(event.command.clone());
}
let output = std::process::Command::new(bin)
.args(&args)
.stdin(std::process::Stdio::null())
.output()
.ok()?;
let stdout = String::from_utf8_lossy(&output.stdout);
let line = stdout.trim().lines().last().unwrap_or("").trim();
if !line.starts_with('{') {
return None;
}
let choice = json_field(line, "choice").unwrap_or_else(|| "unclassified".to_string());
let gate = json_field(line, "gate").unwrap_or_else(|| "hold".to_string());
let mode = json_field(line, "mode").unwrap_or_else(|| "shadow".to_string());
let blocked = line.contains("\"blocked\":true");
let mut verdict = crate::policy::GateVerdict::simple(&mode, &choice, &gate, blocked);
verdict.bypass = line.contains("\"bypass\":true");
Some(verdict)
}

fn json_field(text: &str, key: &str) -> Option<String> {
let needle = format!("\"{key}\"");
let rest = text[text.find(&needle)? + needle.len()..].trim_start().strip_prefix(':')?.trim_start();
let rest = rest.strip_prefix('"')?;
Some(rest.split('"').next().unwrap_or("").to_string())
}

fn diff_argument(args: &[String]) -> String {
Expand Down
Loading
Loading