use std::path::{Path, PathBuf};
use std::time::Duration;
use serde_json::{json, Value as Json};
use super::config::{self, Config};
use super::rules::RuleSet;
pub const MAX_INPUT_BYTES: usize = 4 * 1024 * 1024;
pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(3);
pub const EVENTS: &[&str] = &["PreToolUse", "PostToolUse", "PostToolUseFailure", "Stop"];
pub const COMMAND_TOOLS: &[&str] = &["Bash", "PowerShell"];
pub const EDIT_TOOLS: &[&str] = &["Edit", "Write", "MultiEdit", "NotebookEdit"];
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Report {
pub did: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Input {
pub event: String,
pub cwd: Option<PathBuf>,
pub tool: Option<String>,
pub tool_use_id: Option<String>,
pub command: Option<String>,
pub file: Option<String>,
pub error: Option<String>,
pub output: Option<String>,
pub exit_status: Option<i64>,
}
impl Input {
pub fn parse(text: &str) -> Option<Input> {
let json: Json = serde_json::from_str(text).ok()?;
let event = json["hook_event_name"].as_str()?.to_owned();
let tool_input = &json["tool_input"];
Some(Input {
event,
cwd: json["cwd"].as_str().map(PathBuf::from),
tool: json["tool_name"].as_str().map(str::to_owned),
tool_use_id: json["tool_use_id"].as_str().map(str::to_owned),
command: tool_input["command"].as_str().map(str::to_owned),
file: tool_input["file_path"]
.as_str()
.or_else(|| tool_input["notebook_path"].as_str())
.map(str::to_owned),
error: json["error"].as_str().map(str::to_owned),
output: {
let response = &json["tool_response"];
let stdout = response["stdout"].as_str().unwrap_or("");
let stderr = response["stderr"].as_str().unwrap_or("");
response
.is_object()
.then(|| match (stdout.is_empty(), stderr.is_empty()) {
(_, true) => stdout.to_owned(),
(true, false) => stderr.to_owned(),
(false, false) => format!("{stdout}\n{stderr}"),
})
},
exit_status: json["tool_response"]["exit_code"].as_i64(),
})
}
fn is_command_tool(&self) -> bool {
self.tool
.as_deref()
.is_some_and(|t| COMMAND_TOOLS.contains(&t))
}
fn is_edit_tool(&self) -> bool {
self.tool
.as_deref()
.is_some_and(|t| EDIT_TOOLS.contains(&t))
}
}
pub fn exit_code_of(error: &str) -> Option<i64> {
error
.lines()
.next()?
.trim()
.strip_prefix("Exit code ")?
.trim()
.parse()
.ok()
}
pub fn wrapped_exit_of(output: &str) -> Option<i64> {
last_line(output)?
.strip_prefix("exit:")?
.trim()
.parse()
.ok()
}
fn last_line(text: &str) -> Option<String> {
text.lines()
.rev()
.map(str::trim)
.find(|l| !l.is_empty())
.map(str::to_owned)
}
fn last_line_before_exit(output: &str) -> Option<String> {
let mut lines: Vec<&str> = output.lines().map(str::trim).collect();
while lines.last().is_some_and(|l| l.is_empty()) {
lines.pop();
}
if lines.last().is_some_and(|l| l.starts_with("exit:")) {
lines.pop();
}
lines
.into_iter()
.rev()
.find(|l| !l.is_empty())
.map(str::to_owned)
}
pub fn file_key(root: &Path, file: &str) -> String {
let normalised = file.replace('\\', "/");
let root_text = root.display().to_string().replace('\\', "/");
let stripped = normalised
.strip_prefix(&root_text)
.map(|rest| rest.trim_start_matches('/'))
.filter(|rest| !rest.is_empty())
.map(str::to_owned);
stripped.unwrap_or(normalised)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Verdict {
pub outcome: &'static str,
pub check: Option<String>,
pub exit_code: Option<i64>,
pub timed_out: bool,
pub timeout_seconds: Option<u64>,
pub last_line: Option<String>,
}
impl Verdict {
fn none() -> Verdict {
Verdict {
outcome: "none",
check: None,
exit_code: None,
timed_out: false,
timeout_seconds: None,
last_line: None,
}
}
fn by_check(root: &Path, config: &Config) -> Option<Verdict> {
let check = config.check.as_deref()?;
let ran = crate::plans::run(root, check, config.timeout());
Some(Verdict {
outcome: if ran.passed() { "passed" } else { "failed" },
check: Some(check.to_owned()),
exit_code: ran.exit_code.map(i64::from),
timed_out: ran.timed_out,
timeout_seconds: Some(config.timeout().as_secs()),
last_line: ran.last_line().map(str::to_owned),
})
}
fn by_action(input: &Input) -> Verdict {
let own = |exit_code: i64, last_line: Option<String>| Verdict {
outcome: if exit_code == 0 { "passed" } else { "failed" },
check: None,
exit_code: Some(exit_code),
timed_out: false,
timeout_seconds: None,
last_line: if exit_code == 0 { None } else { last_line },
};
if let Some(error) = &input.error {
return Verdict {
outcome: "failed",
check: None,
exit_code: exit_code_of(error),
timed_out: false,
timeout_seconds: None,
last_line: last_line(error),
};
}
let output = input.output.as_deref().unwrap_or("");
if let Some(code) = wrapped_exit_of(output) {
return own(code, last_line_before_exit(output));
}
if let Some(code) = input.exit_status {
return own(code, last_line(output));
}
own(0, None)
}
fn fields(&self, body: &mut Json) {
body["outcome"] = json!(self.outcome);
body["check"] = json!(self.check);
body["exit_code"] = json!(self.exit_code);
body["timed_out"] = json!(self.timed_out);
body["timeout_seconds"] = json!(self.timeout_seconds);
body["last_line"] = json!(self.last_line);
}
}
pub fn run(client: &str, text: &str) -> Report {
let did = |s: &str| Report { did: s.to_owned() };
let Some(input) = Input::parse(text) else {
return did("the event could not be read");
};
if !EVENTS.contains(&input.event.as_str()) {
return did("not an event autopilot acts on");
}
let cwd = input
.cwd
.clone()
.or_else(|| std::env::var_os("CLAUDE_PROJECT_DIR").map(PathBuf::from))
.or_else(|| std::env::current_dir().ok());
let Some(cwd) = cwd else {
return did("no working directory");
};
let Some(root) = crate::namespace::repository_root(&cwd) else {
return did("not in a repository");
};
let Some(config) = config::read(&root).config().cloned() else {
return did("autopilot is not switched on here");
};
if !config.forks() {
return did("automatic forks are off here");
}
if !crate::policy::allows(crate::policy::Feature::Autopilot) {
return did("the machine policy switches autopilot off");
}
let env_ns = std::env::var(crate::namespace::NAMESPACE_ENV).ok();
let Ok(namespace) = crate::namespace::resolve(None, env_ns.as_deref(), &cwd) else {
return did("no usable namespace");
};
let Ok(dir) = crate::persist::datadir::here() else {
return did("no data directory");
};
let Ok(Some(endpoint)) = crate::daemon::usable(&dir.path) else {
return did("no daemon is running");
};
if endpoint.port.is_none() {
return did("no daemon is running");
}
let Ok(daemon) = crate::client::Daemon::new(&endpoint) else {
return did("the endpoint file is unusable");
};
let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
else {
return did("no runtime");
};
let post = |body: Json| -> Option<Json> {
let (status, answer) = runtime
.block_on(daemon.post_within(super::PATH, &body, REQUEST_TIMEOUT))
.ok()?;
(status == 200).then_some(answer)
};
let base = |action: &str| {
json!({
"action": action,
"client": client,
"namespace": namespace.name,
"tool_use_id": input.tool_use_id,
})
};
match input.event.as_str() {
"PreToolUse" if input.is_command_tool() => {
let Some(command) = input.command.as_deref() else {
return did("no command");
};
let Ok(rules) = RuleSet::for_project(&config.extra_rules, &config.ignore_rules) else {
return did("the project's rules do not compile");
};
let Some(rule) = rules.matches(command) else {
return did("not risky");
};
let mut body = base("fork");
body["rule"] = json!(rule.name);
body["command"] = json!(command);
match post(body) {
Some(answer) => did(&format!("forked {}", answer["forked"])),
None => did("the daemon could not be told"),
}
}
"PreToolUse" if input.is_edit_tool() => {
let Some(file) = input.file.as_deref() else {
return did("no file");
};
let mut body = base("edit");
body["file"] = json!(file_key(&root, file));
body["max_files"] = json!(config.max_files);
match post(body) {
Some(answer) => did(&format!("edit noted; forked {}", answer["forked"])),
None => did("the daemon could not be told"),
}
}
"PreToolUse" => did("not a tool autopilot watches"),
"PostToolUse" | "PostToolUseFailure" => {
if !input.is_command_tool() {
return did("not a tool autopilot settles by");
}
let open = post(base("open"));
let Some(open) = open.filter(|o| o["open"].as_array().is_some_and(|a| !a.is_empty()))
else {
return did("no fork is open for this action");
};
let verdict =
Verdict::by_check(&root, &config).unwrap_or_else(|| Verdict::by_action(&input));
let mut body = base("settle");
verdict.fields(&mut body);
match post(body) {
Some(answer) => did(&format!(
"settled {} as {}: {}",
open["open"].as_array().map_or(0, Vec::len),
verdict.outcome,
answer["settled"]
)),
None => did("the daemon could not be told"),
}
}
_ => {
let mut ask = base("open");
ask["tool_use_id"] = Json::Null;
let open = post(ask);
let Some(_) = open.filter(|o| o["open"].as_array().is_some_and(|a| !a.is_empty()))
else {
return did("nothing is open");
};
let verdict = Verdict::by_check(&root, &config).unwrap_or_else(Verdict::none);
let mut body = base("settle");
body["tool_use_id"] = Json::Null;
verdict.fields(&mut body);
match post(body) {
Some(answer) => did(&format!(
"settled at stop as {}: {}",
verdict.outcome, answer["settled"]
)),
None => did("the daemon could not be told"),
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_events_shape_is_read_as_documented() {
let pre = Input::parse(
r#"{"session_id":"abc","cwd":"C:\\p","hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{"command":"npm test","description":"x"},"tool_use_id":"toolu_01"}"#,
)
.unwrap();
assert_eq!(pre.event, "PreToolUse");
assert_eq!(pre.tool.as_deref(), Some("Bash"));
assert_eq!(pre.command.as_deref(), Some("npm test"));
assert_eq!(pre.tool_use_id.as_deref(), Some("toolu_01"));
assert_eq!(pre.cwd.as_deref(), Some(Path::new("C:\\p")));
assert!(pre.is_command_tool() && !pre.is_edit_tool());
let edit = Input::parse(
r#"{"hook_event_name":"PreToolUse","tool_name":"Write","tool_input":{"file_path":"C:\\project\\src\\index.ts","content":"..."}}"#,
)
.unwrap();
assert!(edit.is_edit_tool());
assert_eq!(edit.file.as_deref(), Some("C:\\project\\src\\index.ts"));
let failed = Input::parse(
r#"{"hook_event_name":"PostToolUseFailure","tool_name":"Bash","tool_input":{"command":"npm test"},"tool_use_id":"t","error":"Exit code 1\nError: Cannot find module 'express'","is_interrupt":false}"#,
)
.unwrap();
assert_eq!(exit_code_of(failed.error.as_deref().unwrap()), Some(1));
let v = Verdict::by_action(&failed);
assert_eq!(v.outcome, "failed");
assert_eq!(v.exit_code, Some(1));
assert_eq!(
v.last_line.as_deref(),
Some("Error: Cannot find module 'express'")
);
let ok = Verdict::by_action(&Input::parse(r#"{"hook_event_name":"PostToolUse","tool_name":"Bash","tool_input":{"command":"x"}}"#).unwrap());
assert_eq!((ok.outcome, ok.exit_code), ("passed", Some(0)));
assert_eq!(exit_code_of("spawn failed"), None);
assert!(Input::parse("not json").is_none());
assert!(Input::parse(r#"{"cwd":"x"}"#).is_none());
}
#[test]
fn a_wrapped_command_is_judged_by_its_exit_line_not_the_wrappers_status() {
let wrapped = "npm install left-pad 2>&1; echo \"exit: $?\"";
let post = |response: Json| {
let mut event = json!({
"hook_event_name": "PostToolUse", "tool_name": "Bash",
"tool_input": { "command": wrapped }, "tool_use_id": "t",
});
event["tool_response"] = response;
Input::parse(&event.to_string()).unwrap()
};
let stdout = "npm ERR! code E404\nnpm ERR! 404 Not Found - GET https://registry.npmjs.org/left-pad\n\nexit: 1\n";
let failed =
post(json!({ "stdout": stdout, "stderr": "", "exit_code": 0, "interrupted": false }));
assert_eq!(failed.exit_status, Some(0));
let v = Verdict::by_action(&failed);
assert_eq!((v.outcome, v.exit_code), ("failed", Some(1)));
assert_eq!(
v.last_line.as_deref(),
Some("npm ERR! 404 Not Found - GET https://registry.npmjs.org/left-pad")
);
let passed = post(
json!({ "stdout": "added 1 package\nexit: 0", "stderr": "", "exit_code": 0, "interrupted": false }),
);
let v = Verdict::by_action(&passed);
assert_eq!(
(v.outcome, v.exit_code, v.last_line),
("passed", Some(0), None)
);
let status =
post(json!({ "stdout": "boom", "stderr": "", "exit_code": 2, "interrupted": false }));
let v = Verdict::by_action(&status);
assert_eq!(
(v.outcome, v.exit_code, v.last_line.as_deref()),
("failed", Some(2), Some("boom"))
);
let stderr =
post(json!({ "stdout": "", "stderr": "fatal\nexit: 128", "interrupted": false }));
let v = Verdict::by_action(&stderr);
assert_eq!(
(v.outcome, v.exit_code, v.last_line.as_deref()),
("failed", Some(128), Some("fatal"))
);
let mut event = json!({
"hook_event_name": "PostToolUseFailure", "tool_name": "Bash",
"tool_input": { "command": wrapped }, "tool_use_id": "t",
"error": "Command timed out after 2m 0.0s\nexit: 0",
});
event["tool_response"] = json!({ "stdout": "exit: 0", "exit_code": 0 });
let v = Verdict::by_action(&Input::parse(&event.to_string()).unwrap());
assert_eq!((v.outcome, v.exit_code), ("failed", None));
assert_eq!(wrapped_exit_of("exit: 7"), Some(7));
assert_eq!(wrapped_exit_of(" exit: 7 \n\n"), Some(7));
assert_eq!(wrapped_exit_of("exit: seven"), None);
assert_eq!(wrapped_exit_of("done"), None);
assert_eq!(wrapped_exit_of(""), None);
}
#[test]
fn a_file_is_counted_relative_to_the_project_with_forward_slashes() {
let root = Path::new("C:\\project");
assert_eq!(file_key(root, "C:\\project\\src\\index.ts"), "src/index.ts");
assert_eq!(
file_key(Path::new("/home/a/p"), "/home/a/p/src/x.rs"),
"src/x.rs"
);
assert_eq!(file_key(Path::new("/home/a/p"), "/etc/hosts"), "/etc/hosts");
}
#[test]
fn without_a_daemon_or_a_repository_the_hook_does_nothing_and_says_why() {
let dir = tempfile::tempdir().unwrap();
let event = format!(
r#"{{"hook_event_name":"PreToolUse","cwd":{},"tool_name":"Bash","tool_input":{{"command":"rm -rf x"}}}}"#,
serde_json::to_string(&dir.path().display().to_string()).unwrap()
);
assert_eq!(run("claude-code", &event).did, "not in a repository");
std::fs::create_dir_all(dir.path().join(".git")).unwrap();
assert_eq!(
run("claude-code", &event).did,
"autopilot is not switched on here"
);
std::fs::write(dir.path().join(config::FILE), config::template(None)).unwrap();
let report = run("claude-code", &event);
assert!(
report.did == "no daemon is running" || report.did == "no data directory",
"{}",
report.did
);
assert_eq!(
run("claude-code", "garbage").did,
"the event could not be read"
);
assert_eq!(
run("claude-code", r#"{"hook_event_name":"SessionStart"}"#).did,
"not an event autopilot acts on"
);
}
}