Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
158 lines
6.6 KiB
Rust
158 lines
6.6 KiB
Rust
//! Ask resolution — deny blocks, and an ask round-trips as reject, once or always.
|
|
|
|
use luxe_core::engine::{Action, Engine};
|
|
use luxe_core::hook::HookPoint;
|
|
use luxe_core::permission::{
|
|
AskResolution, PermValue, PermissionAction, PermissionConfig, PermissionEngine,
|
|
PermissionReply, PermissionSettings,
|
|
};
|
|
use luxe_core::session::{JsonlSessionStore, SessionStore};
|
|
use luxe_core::HookRegistry;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
use std::sync::Arc;
|
|
use tokio::sync::Mutex;
|
|
|
|
use crate::fixtures::*;
|
|
|
|
#[tokio::test]
|
|
async fn deny_blocks_the_tool() {
|
|
let (tx, mut rx, runs) =
|
|
spawn(bash_policy(PermissionAction::Deny, AskResolution::Prompt)).await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", None).await;
|
|
assert_eq!(prompts, 0, "deny should not prompt");
|
|
assert_eq!(runs.load(Ordering::SeqCst), 0, "denied tool must not run");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn ask_reject_blocks_the_tool() {
|
|
let (tx, mut rx, runs) = spawn(bash_policy(PermissionAction::Ask, AskResolution::Prompt)).await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", Some(PermissionReply::Reject)).await;
|
|
assert_eq!(prompts, 1, "ask should prompt once");
|
|
assert_eq!(runs.load(Ordering::SeqCst), 0, "rejected tool must not run");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn ask_once_allows_the_tool() {
|
|
let (tx, mut rx, runs) = spawn(bash_policy(PermissionAction::Ask, AskResolution::Prompt)).await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", Some(PermissionReply::Once)).await;
|
|
assert_eq!(prompts, 1);
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1, "approved tool must run once");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn ask_always_persists_across_the_session() {
|
|
let (tx, mut rx, runs) = spawn(bash_policy(PermissionAction::Ask, AskResolution::Prompt)).await;
|
|
// First turn: approve "always" — should prompt once and run.
|
|
let first = run_turn_answering(&tx, &mut rx, "go", Some(PermissionReply::Always)).await;
|
|
assert_eq!(first, 1);
|
|
// Second turn, same command family: no prompt, auto-allowed by the session approval.
|
|
let second = run_turn_answering(&tx, &mut rx, "again", Some(PermissionReply::Reject)).await;
|
|
assert_eq!(second, 0, "always-approved family should not prompt again");
|
|
assert_eq!(runs.load(Ordering::SeqCst), 2, "both calls run");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn ask_prompt_fires_the_observational_permission_hook_points() {
|
|
let (tx, mut rx, runs, points) = spawn_with_hooks(
|
|
bash_policy(PermissionAction::Ask, AskResolution::Prompt),
|
|
HookRegistry::new(),
|
|
)
|
|
.await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", Some(PermissionReply::Once)).await;
|
|
assert_eq!(prompts, 1);
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1);
|
|
// The interactive prompt must bracket the wait with requested → resolved so observers (e.g.
|
|
// the Herdr integration) can flip blocked → working around the human decision.
|
|
assert_eq!(
|
|
*points.lock().await,
|
|
vec![HookPoint::PermissionRequested, HookPoint::PermissionResolved],
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn auto_allow_fires_no_permission_hook_points() {
|
|
let (tx, mut rx, runs, points) = spawn_with_hooks(
|
|
bash_policy(PermissionAction::Ask, AskResolution::AutoAllow),
|
|
HookRegistry::new(),
|
|
)
|
|
.await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", None).await;
|
|
assert_eq!(prompts, 0);
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1);
|
|
// No interactive prompt → the turn never blocks → no permission hook points fire.
|
|
assert!(points.lock().await.is_empty(), "auto-allow must not fire permission hook points");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn auto_allow_runs_without_prompting() {
|
|
let (tx, mut rx, runs) =
|
|
spawn(bash_policy(PermissionAction::Ask, AskResolution::AutoAllow)).await;
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", None).await;
|
|
assert_eq!(prompts, 0, "auto-allow never prompts");
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1, "auto-allowed tool runs");
|
|
}
|
|
|
|
/// "Allow always" writes the approval to the permissions file, so a *new* engine over that file
|
|
/// runs the same call without prompting — the session-scoped tier can't do that.
|
|
#[tokio::test]
|
|
async fn always_persist_writes_a_rule_that_survives_a_restart() {
|
|
let tmp = tempfile::tempdir().unwrap();
|
|
let permissions_path = tmp.path().join("permissions.json");
|
|
|
|
// First run: bash asks, the user saves the approval.
|
|
let store_dir = tmp.path().join("sessions-a");
|
|
let mut store = JsonlSessionStore::new(store_dir);
|
|
let session_id = store.create("/tmp/perm-persist").unwrap();
|
|
let runs = Arc::new(AtomicUsize::new(0));
|
|
let provider = Arc::new(BashCaller::running("echo hi"));
|
|
let (tx, mut rx) = Engine::spawn(config(
|
|
store,
|
|
session_id,
|
|
provider,
|
|
runs.clone(),
|
|
Arc::new(Mutex::new(Vec::new())),
|
|
bash_policy(PermissionAction::Ask, AskResolution::Prompt),
|
|
HookRegistry::new(),
|
|
Some(permissions_path.clone()),
|
|
));
|
|
let prompts =
|
|
run_turn_answering(&tx, &mut rx, "go", Some(PermissionReply::AlwaysPersist)).await;
|
|
assert_eq!(prompts, 1);
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1);
|
|
let _ = tx.send(Action::Close).await;
|
|
|
|
// The file now carries the approval.
|
|
let saved = std::fs::read_to_string(&permissions_path).expect("the approval was written");
|
|
let file = luxe_core::permission::PermissionsFile::from_json(&saved).expect("valid json");
|
|
let persisted = file.ruleset();
|
|
assert!(!persisted.is_empty(), "a rule was recorded: {saved}");
|
|
|
|
// Second run: the same policy plus the persisted rules — no prompt this time.
|
|
let mut store = JsonlSessionStore::new(tmp.path().join("sessions-b"));
|
|
let session_id = store.create("/tmp/perm-persist").unwrap();
|
|
let runs = Arc::new(AtomicUsize::new(0));
|
|
let provider = Arc::new(BashCaller::running("echo hi"));
|
|
let mut global = PermissionConfig::Keyed(
|
|
[("bash".to_string(), PermValue::Scalar(PermissionAction::Ask))].into_iter().collect(),
|
|
)
|
|
.to_ruleset();
|
|
global.extend(persisted);
|
|
let (tx, mut rx) = Engine::spawn(config(
|
|
store,
|
|
session_id,
|
|
provider,
|
|
runs.clone(),
|
|
Arc::new(Mutex::new(Vec::new())),
|
|
PermissionSettings {
|
|
engine: PermissionEngine::new(global, vec![], false),
|
|
ask: AskResolution::Prompt,
|
|
},
|
|
HookRegistry::new(),
|
|
Some(permissions_path),
|
|
));
|
|
let prompts = run_turn_answering(&tx, &mut rx, "go", None).await;
|
|
assert_eq!(prompts, 0, "the saved approval applies without asking again");
|
|
assert_eq!(runs.load(Ordering::SeqCst), 1, "and the tool still runs");
|
|
let _ = tx.send(Action::Close).await;
|
|
}
|