Initial public release

Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
Evan Whittaker
2026-10-17 12:08:30 -05:00
commit 09a7de2520
1730 changed files with 412952 additions and 0 deletions

View File

@@ -0,0 +1,157 @@
//! 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;
}