Files
luxe/crates/luxe-core/src/local_endpoint/ancestry.rs
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

116 lines
4.4 KiB
Rust

//! Ancestry — whether a process was started, at any depth, by another.
//!
//! The tripwire that keeps a luxe's own children (the agent's `bash`, a hook) from joining its
//! session and answering their own prompts. A tripwire, not a wall: a process that detaches itself
//! leaves the chain, and the documentation says so. Blocking: run it off the async runtime.
/// How many parents to walk before giving up; real chains are a handful deep.
const MAX_DEPTH: usize = 64;
/// Whether `pid` is `ancestor` or was started, at any depth, by it. `false` when the chain cannot
/// be read, so a client this cannot place is let in, as it would be without the tripwire.
pub fn descends_from(pid: u32, ancestor: u32) -> bool {
descends_in(pid, ancestor, parent_lookup())
}
/// [`descends_from`] over an explicit parent table.
fn descends_in(pid: u32, ancestor: u32, parent_of: impl Fn(u32) -> Option<u32>) -> bool {
let mut current = pid;
for _ in 0..MAX_DEPTH {
if current == ancestor {
return true;
}
match parent_of(current) {
Some(parent) if parent != current && parent != 0 => current = parent,
_ => return false,
}
}
false
}
#[cfg(target_os = "linux")]
fn parent_lookup() -> impl Fn(u32) -> Option<u32> {
|pid| parent_in_stat(&std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?)
}
/// The parent id from a `/proc/<pid>/stat` line. The command name sits in parentheses and may hold
/// spaces and parentheses itself, so fields are counted from the last `)`.
#[cfg(any(target_os = "linux", test))]
fn parent_in_stat(stat: &str) -> Option<u32> {
let (_, fields) = stat.rsplit_once(')')?;
fields.split_whitespace().nth(1)?.parse().ok()
}
#[cfg(all(unix, not(target_os = "linux")))]
fn parent_lookup() -> impl Fn(u32) -> Option<u32> {
let table = process_table();
move |pid| table.get(&pid).copied()
}
/// Every process's parent, from `ps`, which macOS and the BSDs all have at the same path.
#[cfg(all(unix, not(target_os = "linux")))]
fn process_table() -> std::collections::HashMap<u32, u32> {
let listing = std::process::Command::new("/bin/ps").args(["-A", "-o", "pid=,ppid="]).output();
let Ok(listing) = listing else {
return std::collections::HashMap::new();
};
String::from_utf8_lossy(&listing.stdout)
.lines()
.filter_map(|line| {
let mut ids = line.split_whitespace().map(str::parse::<u32>);
Some((ids.next()?.ok()?, ids.next()?.ok()?))
})
.collect()
}
#[cfg(windows)]
fn parent_lookup() -> impl Fn(u32) -> Option<u32> {
let table = super::windows::process_parents();
move |pid| table.get(&pid).copied()
}
#[cfg(test)]
mod tests {
use super::*;
/// A process is its own descendant, a grandchild is found through its parent, and an
/// unrelated process or a broken chain is not.
#[test]
fn the_chain_is_walked_to_the_ancestor_and_no_further() {
let parents = |pid| match pid {
30 => Some(20),
20 => Some(10),
10 => Some(1),
1 => Some(0),
_ => None,
};
assert!(descends_in(30, 10, parents), "a grandchild");
assert!(descends_in(10, 10, parents), "itself");
assert!(!descends_in(10, 30, parents), "a parent is not a child");
assert!(!descends_in(99, 10, parents), "unknown, so not placed");
assert!(!descends_in(7, 10, |_| Some(7)), "a process that is its own parent ends the walk");
}
/// The parent is the fourth field, counted after a command name that can hold anything.
#[test]
fn the_parent_is_read_past_an_awkward_command_name() {
assert_eq!(parent_in_stat("4242 (bash) S 4000 4242 4242 0"), Some(4000));
assert_eq!(parent_in_stat("4242 (my (odd) prog) R 17 4242"), Some(17));
assert_eq!(parent_in_stat("garbage"), None);
}
/// A real child of this test is found, and this test is not the child's.
#[test]
#[cfg(unix)]
fn a_real_child_descends_from_this_process() {
let mut child = std::process::Command::new("sleep").arg("5").spawn().expect("sleep runs");
let (child_id, own_id) = (child.id(), std::process::id());
let found = descends_from(child_id, own_id);
let reversed = descends_from(own_id, child_id);
let _ = child.kill();
let _ = child.wait();
assert!(found, "the child is placed under this process");
assert!(!reversed);
}
}