mod measure;
mod post_edit;
mod pre_bash;
mod pre_edit;
pub use post_edit::{advisory_for, run_post_edit};
pub use pre_bash::run_pre_bash;
pub use pre_edit::{run_pre_edit, Outcome};
pub(crate) use measure::{measure_with_graph, Sizing};
use std::path::PathBuf;
use serde::Deserialize;
#[derive(Debug, Default, Deserialize)]
pub struct HookInput {
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub tool_name: Option<String>,
#[serde(default)]
pub tool_input: ToolInput,
}
#[derive(Debug, Default, Deserialize)]
pub struct ToolInput {
#[serde(default)]
pub file_path: Option<String>,
#[serde(default)]
pub old_string: Option<String>,
#[serde(default)]
pub new_string: Option<String>,
#[serde(default)]
pub content: Option<String>,
#[serde(default)]
pub edits: Vec<EditItem>,
}
#[derive(Debug, Default, Deserialize)]
pub struct EditItem {
#[serde(default)]
pub old_string: Option<String>,
#[serde(default)]
pub new_string: Option<String>,
}
impl HookInput {
#[must_use]
pub fn parse(input_json: &str) -> Option<Self> {
serde_json::from_str(input_json).ok()
}
#[must_use]
pub fn root(&self, default_root: &std::path::Path) -> PathBuf {
self.cwd
.as_ref()
.map_or_else(|| default_root.to_path_buf(), PathBuf::from)
}
#[must_use]
pub fn replaced_texts(&self) -> Vec<&str> {
let mut texts: Vec<&str> = Vec::new();
if let Some(old) = self.tool_input.old_string.as_deref() {
texts.push(old);
}
for edit in &self.tool_input.edits {
if let Some(old) = edit.old_string.as_deref() {
texts.push(old);
}
}
texts
}
}
#[must_use]
pub fn deny_envelope(reason: &str) -> String {
serde_json::json!({
"hookSpecificOutput": {
"hookEventName": "PreToolUse",
"permissionDecision": "deny",
"permissionDecisionReason": reason,
}
})
.to_string()
}
#[must_use]
pub fn system_message(message: &str) -> String {
serde_json::json!({ "systemMessage": message }).to_string()
}
#[must_use]
pub fn first_notice_for_session(session: Option<&str>, kind: &str) -> bool {
let Some(session) = session else {
return true;
};
let safe: String = session
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_')
.take(64)
.collect();
if safe.is_empty() {
return true;
}
let kind_safe: String = kind
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_')
.take(80)
.collect();
let marker = std::env::temp_dir().join(format!("hank-guard-failopen-{safe}-{kind_safe}"));
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&marker)
{
Ok(_) => true,
Err(e) => e.kind() != std::io::ErrorKind::AlreadyExists,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_an_edit_payload() {
let payload = serde_json::json!({
"session_id": "s1",
"cwd": "/repo",
"tool_name": "Edit",
"tool_input": { "file_path": "/repo/a.rs", "old_string": "fn a", "new_string": "fn b" },
})
.to_string();
let input = HookInput::parse(&payload).unwrap();
assert_eq!(input.tool_name.as_deref(), Some("Edit"));
assert_eq!(input.replaced_texts(), vec!["fn a"]);
}
#[test]
fn parses_a_multiedit_payload() {
let payload = serde_json::json!({
"tool_name": "MultiEdit",
"tool_input": { "file_path": "/repo/a.rs", "edits": [
{ "old_string": "one", "new_string": "1" },
{ "old_string": "two", "new_string": "2" },
]},
})
.to_string();
let input = HookInput::parse(&payload).unwrap();
assert_eq!(input.replaced_texts(), vec!["one", "two"]);
}
#[test]
fn a_write_has_no_replaced_text() {
let payload = serde_json::json!({
"tool_name": "Write",
"tool_input": { "file_path": "/repo/a.rs", "content": "fn a() {}" },
})
.to_string();
let input = HookInput::parse(&payload).unwrap();
assert!(input.replaced_texts().is_empty());
assert_eq!(input.tool_input.content.as_deref(), Some("fn a() {}"));
}
#[test]
fn unknown_fields_and_missing_fields_are_tolerated() {
let payload = serde_json::json!({ "brand_new_field": 42, "tool_input": {} }).to_string();
let input = HookInput::parse(&payload).unwrap();
assert!(input.tool_input.file_path.is_none());
assert!(HookInput::parse("not json").is_none());
}
#[test]
fn deny_envelope_matches_the_documented_protocol() {
let value: serde_json::Value = serde_json::from_str(&deny_envelope("too big")).unwrap();
let out = &value["hookSpecificOutput"];
assert_eq!(out["hookEventName"], "PreToolUse");
assert_eq!(out["permissionDecision"], "deny");
assert_eq!(out["permissionDecisionReason"], "too big");
}
#[test]
fn system_message_carries_no_permission_decision() {
let value: serde_json::Value = serde_json::from_str(&system_message("heads up")).unwrap();
assert_eq!(value["systemMessage"], "heads up");
assert!(value.get("hookSpecificOutput").is_none());
}
#[test]
fn fail_open_notice_fires_once_per_session() {
let session = format!("test-{}", std::process::id());
assert!(first_notice_for_session(Some(&session), "config"));
assert!(!first_notice_for_session(Some(&session), "config"));
assert!(first_notice_for_session(
Some(&session),
"deadline-src/a.rs"
));
assert!(!first_notice_for_session(
Some(&session),
"deadline-src/a.rs"
));
assert!(first_notice_for_session(
Some(&session),
"deadline-src/b.rs"
));
for kind in ["config", "deadline-src/a.rs", "deadline-src/b.rs"] {
let safe_kind: String = kind
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '-' || *c == '_')
.take(80)
.collect();
let _ = std::fs::remove_file(
std::env::temp_dir().join(format!("hank-guard-failopen-{session}-{safe_kind}")),
);
}
assert!(first_notice_for_session(None, "config"));
}
}