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:
288
crates/luxe-core/src/program.rs
Normal file
288
crates/luxe-core/src/program.rs
Normal file
@@ -0,0 +1,288 @@
|
||||
//! Program resolution — find an external tool that is installed but not on `PATH`.
|
||||
//!
|
||||
//! Luxe drives a lot of external programs: language servers, debug adapters, formatters, `git`,
|
||||
//! `ast-grep`. Resolving them through `PATH` alone reports "not installed" for a tool that is
|
||||
//! sitting on disk, because a package manager's bin directory and the launching process's `PATH`
|
||||
//! are different things. `cargo install` writes to `~/.cargo/bin` whether or not that directory was
|
||||
//! ever added to a shell profile; `pipx`, `npm -g`, `go install`, and Homebrew each have their own.
|
||||
//! An app also inherits whatever environment launched it, which for a desktop entry, a systemd
|
||||
//! unit, or an editor's integrated terminal is often not the user's login shell.
|
||||
//!
|
||||
//! So: try `PATH` first (it is the user's stated preference), then the well-known install
|
||||
//! directories. A tool that is genuinely absent still reports absent, with its install hint intact.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
mod bounded;
|
||||
mod nesting;
|
||||
mod opener;
|
||||
mod process;
|
||||
|
||||
pub use bounded::{run_bounded, run_bounded_with_input, BoundedRunError};
|
||||
pub use nesting::{
|
||||
check_nesting, claim_nesting_slot, NestingRefused, DEFAULT_MAX_NESTING_DEPTH,
|
||||
MAX_NESTING_DEPTH_VAR, NESTING_DEPTH_VAR,
|
||||
};
|
||||
pub use opener::{
|
||||
desktop_opener, editor, editor_file_args, file_manager, file_manager_from, parse_editor,
|
||||
EditorError,
|
||||
};
|
||||
pub use process::{
|
||||
captured_command, detach_from_terminal, group_members, hostname, kill_tree, process_is_alive,
|
||||
take_stdin, GroupMember,
|
||||
};
|
||||
|
||||
/// Directories a package manager drops executables into, checked after `PATH`.
|
||||
///
|
||||
/// Ordered by how likely the entry is to be the one a developer meant: language toolchains first,
|
||||
/// then the generic user bin directory, then system-wide installs.
|
||||
fn well_known_bin_dirs() -> Vec<PathBuf> {
|
||||
let home = crate::user_dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
|
||||
let mut dirs = vec![
|
||||
home.join(".cargo").join("bin"),
|
||||
home.join(".local").join("bin"),
|
||||
home.join("go").join("bin"),
|
||||
home.join(".bun").join("bin"),
|
||||
home.join(".deno").join("bin"),
|
||||
home.join(".npm-global").join("bin"),
|
||||
];
|
||||
if cfg!(windows) {
|
||||
dirs.extend(windows_bin_dirs());
|
||||
} else {
|
||||
dirs.push(PathBuf::from("/opt/homebrew/bin"));
|
||||
dirs.push(PathBuf::from("/usr/local/bin"));
|
||||
}
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Where Windows keeps installed programs that its installers did not put on `PATH`.
|
||||
///
|
||||
/// Scoop and winget shim their own directories onto `PATH`, so the interesting entries are Git for
|
||||
/// Windows and Chocolatey. Git matters most: its default install adds only `Git\cmd` (which holds
|
||||
/// `git.exe` and little else), so the unix tools a coding agent leans on sit on disk, one directory
|
||||
/// away, invisible to a `PATH` lookup.
|
||||
fn windows_bin_dirs() -> Vec<PathBuf> {
|
||||
let mut dirs = Vec::new();
|
||||
let roots = ["ProgramFiles", "ProgramFiles(x86)", "ProgramW6432"]
|
||||
.iter()
|
||||
.filter_map(std::env::var_os)
|
||||
.map(PathBuf::from)
|
||||
.chain(std::env::var_os("LOCALAPPDATA").map(|local| PathBuf::from(local).join("Programs")));
|
||||
for root in roots {
|
||||
dirs.push(root.join("Git").join("bin"));
|
||||
dirs.push(root.join("Git").join("usr").join("bin"));
|
||||
dirs.push(root.join("Git").join("cmd"));
|
||||
}
|
||||
if let Some(data) = std::env::var_os("ProgramData") {
|
||||
dirs.push(PathBuf::from(data).join("chocolatey").join("bin"));
|
||||
}
|
||||
dirs
|
||||
}
|
||||
|
||||
/// Whether `path` is a file we could execute.
|
||||
#[cfg(unix)]
|
||||
fn is_executable(path: &Path) -> bool {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
std::fs::metadata(path)
|
||||
.is_ok_and(|meta| meta.is_file() && meta.permissions().mode() & 0o111 != 0)
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn is_executable(path: &Path) -> bool {
|
||||
path.is_file()
|
||||
}
|
||||
|
||||
/// Resolve `program` to a runnable path: `PATH` first, then the well-known install directories.
|
||||
///
|
||||
/// An absolute or relative path (anything containing a separator) is honored as given. Returns
|
||||
/// `None` only when the program really cannot be found.
|
||||
pub fn resolve(program: &str) -> Option<PathBuf> {
|
||||
let candidate = Path::new(program);
|
||||
// Windows accepts both separators, so checking only `MAIN_SEPARATOR` would treat `tools/rg` as a
|
||||
// bare program name and go looking for it on `PATH`.
|
||||
if candidate.is_absolute() || program.contains('/') || program.contains('\\') {
|
||||
return runnable(candidate).map(|_| candidate.to_path_buf());
|
||||
}
|
||||
|
||||
let dirs = std::env::var_os("PATH")
|
||||
.map(|path| std::env::split_paths(&path).collect::<Vec<_>>())
|
||||
.unwrap_or_default();
|
||||
dirs.into_iter().chain(well_known_bin_dirs()).find_map(|dir| runnable(&dir.join(program)))
|
||||
}
|
||||
|
||||
/// The runnable file at `base`, trying the platform's executable suffixes.
|
||||
///
|
||||
/// On unix a program is its own filename. On Windows the name on disk carries an extension from
|
||||
/// `PATHEXT` — `rg` is `rg.exe`, a shim may be `rg.cmd` — so a bare-name lookup finds nothing at all,
|
||||
/// which reads as "ripgrep is not installed" on a machine where it plainly is.
|
||||
fn runnable(base: &Path) -> Option<PathBuf> {
|
||||
if is_executable(base) {
|
||||
return Some(base.to_path_buf());
|
||||
}
|
||||
if !cfg!(windows) {
|
||||
return None;
|
||||
}
|
||||
for extension in executable_suffixes() {
|
||||
let mut name = base.as_os_str().to_os_string();
|
||||
name.push(&extension);
|
||||
let candidate = PathBuf::from(name);
|
||||
if is_executable(&candidate) {
|
||||
return Some(candidate);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Windows executable suffixes, from `PATHEXT` when it is set.
|
||||
fn executable_suffixes() -> Vec<String> {
|
||||
std::env::var("PATHEXT")
|
||||
.ok()
|
||||
.map(|list| list.split(';').filter(|ext| !ext.is_empty()).map(str::to_string).collect())
|
||||
.unwrap_or_else(|| {
|
||||
[".COM", ".EXE", ".BAT", ".CMD"].iter().map(|ext| (*ext).to_string()).collect()
|
||||
})
|
||||
}
|
||||
|
||||
/// The shell a script-running tool should go through, as `(program, flag)`.
|
||||
///
|
||||
/// The `bash` tool hands whole command lines to a shell, and the model writes those in POSIX: pipes,
|
||||
/// `&&`, globs, quoting. So a POSIX shell is preferred wherever one exists — on Windows that means
|
||||
/// the one Git for Windows ships. `cmd` is the last resort rather than the default, because a command
|
||||
/// written for `sh` mostly fails in it, and failing *differently* is worse than failing clearly.
|
||||
///
|
||||
/// Returns `None` for the shell only if the platform has nothing at all, which cannot happen: unix
|
||||
/// has `sh` and Windows has `cmd`.
|
||||
pub fn shell() -> (PathBuf, &'static str) {
|
||||
if !cfg!(windows) {
|
||||
return (resolve("sh").unwrap_or_else(|| PathBuf::from("sh")), "-c");
|
||||
}
|
||||
match posix_shell_on_windows(resolve, || std::env::var("SystemRoot").ok()) {
|
||||
Some(path) => (path, "-c"),
|
||||
None => (resolve("cmd").unwrap_or_else(|| PathBuf::from("cmd")), "/C"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether [`shell`] found a real POSIX shell, or fell back to `cmd`.
|
||||
///
|
||||
/// The `bash` tool uses this to explain a failure that is really "this box has no shell that speaks
|
||||
/// your command" rather than a problem with the command.
|
||||
pub fn has_posix_shell() -> bool {
|
||||
shell().1 == "-c"
|
||||
}
|
||||
|
||||
/// Find a POSIX shell on Windows, refusing the one that is not what it says.
|
||||
///
|
||||
/// `C:\Windows\System32\bash.exe` is the WSL launcher. It is on `PATH` before anything else the
|
||||
/// moment WSL is installed, and running an agent's commands through it would execute them inside a
|
||||
/// Linux VM with a different filesystem — `cd` into the project would fail, and every subsequent
|
||||
/// error would describe a machine the user is not looking at. So a candidate sitting in the Windows
|
||||
/// system directory is skipped rather than taken.
|
||||
///
|
||||
/// Args: `(program lookup, `%SystemRoot%` lookup)` — both injected so the rule is testable from any
|
||||
/// platform.
|
||||
fn posix_shell_on_windows(
|
||||
lookup: impl Fn(&str) -> Option<PathBuf>,
|
||||
system_root: impl Fn() -> Option<String>,
|
||||
) -> Option<PathBuf> {
|
||||
let system = system_root()
|
||||
.map(|root| PathBuf::from(root).join("System32"))
|
||||
.unwrap_or_else(|| PathBuf::from(r"C:\Windows\System32"));
|
||||
["bash", "sh"]
|
||||
.iter()
|
||||
.filter_map(|name| lookup(name))
|
||||
.find(|path| path.parent().is_none_or(|parent| !crate::paths::contains(&system, parent)))
|
||||
}
|
||||
|
||||
/// Whether `program` can be run at all — `PATH` or a well-known install directory.
|
||||
pub fn is_available(program: &str) -> bool {
|
||||
resolve(program).is_some()
|
||||
}
|
||||
|
||||
/// The first of `programs` that resolves, as `(requested name, runnable path)`.
|
||||
///
|
||||
/// For a tool that ships under more than one name (`fd`/`fdfind`, `ast-grep`/`sg`).
|
||||
pub fn resolve_any<'a>(programs: &[&'a str]) -> Option<(&'a str, PathBuf)> {
|
||||
programs.iter().find_map(|name| resolve(name).map(|path| (*name, path)))
|
||||
}
|
||||
|
||||
/// The copy of `program` a project under `root` supplies for itself, if any.
|
||||
///
|
||||
/// Two conventions, one question. npm links a dev dependency's executable into
|
||||
/// `node_modules/.bin`, and Python installs everything into a virtualenv — in both cases the
|
||||
/// version a repository pins is invisible to [`resolve`], which answers with whatever global copy
|
||||
/// shares the name. The environment is checked first because it belongs to `root` itself, then
|
||||
/// `node_modules/.bin` walking upward, because a workspace hoists: a package in a monorepo has its
|
||||
/// own or shares the root's, and which one depends on the package manager rather than on anything
|
||||
/// the caller can see.
|
||||
///
|
||||
/// **This returns a path to a binary the repository supplied**, so whether to run it is the
|
||||
/// caller's decision and not this module's. Home is skipped on the way up: a stray `~/node_modules`
|
||||
/// belongs to no project and would otherwise answer for every one of them.
|
||||
pub fn project_local(root: &Path, program: &str) -> Option<PathBuf> {
|
||||
// A name with a separator is a path, not something to go looking for.
|
||||
if program.contains('/') || program.contains('\\') {
|
||||
return None;
|
||||
}
|
||||
if let Some(installed) = project_venv(root).and_then(|venv| venv_program(&venv, program)) {
|
||||
return Some(installed);
|
||||
}
|
||||
let home = crate::user_dirs::home_dir();
|
||||
std::iter::successors(Some(root), |dir| dir.parent())
|
||||
.filter(|dir| home.as_deref() != Some(*dir))
|
||||
.find_map(|dir| runnable(&dir.join("node_modules").join(".bin").join(program)))
|
||||
}
|
||||
|
||||
/// Directory names a Python virtualenv conventionally lives under, most idiomatic first.
|
||||
const VENV_DIR_NAMES: &[&str] = &[".venv", "venv", "env"];
|
||||
|
||||
/// The copy of `program` installed into the virtualenv at `venv`, if both exist.
|
||||
///
|
||||
/// A virtualenv's executables are the ones a Python project actually pinned, and they are never on
|
||||
/// `PATH` unless somebody activated it — so [`resolve`] answers with a global interpreter that
|
||||
/// shares nothing with the project but a version number. The layout differs by platform (`bin` on
|
||||
/// unix, `Scripts` on Windows) and that is the whole reason this lives here: a call site that
|
||||
/// hardcodes `bin/python` works everywhere except Windows, silently.
|
||||
pub fn venv_program(venv: &Path, program: &str) -> Option<PathBuf> {
|
||||
if program.contains('/') || program.contains('\\') {
|
||||
return None;
|
||||
}
|
||||
let bin = if cfg!(windows) { "Scripts" } else { "bin" };
|
||||
runnable(&venv.join(bin).join(program))
|
||||
}
|
||||
|
||||
/// The virtualenv a project under `root` carries, if any.
|
||||
///
|
||||
/// An activated `VIRTUAL_ENV` inside the tree wins, because it is the user's own answer and it may
|
||||
/// be named something no list would guess (`.direnv/python-3.12`). One *outside* the tree is
|
||||
/// ignored on purpose: it belongs to another project, and if it should win it is already on `PATH`.
|
||||
///
|
||||
/// Only `root` itself is searched. Walking upward would let a parent directory's environment answer
|
||||
/// for a project that has none, which is the failure this exists to prevent.
|
||||
pub fn project_venv(root: &Path) -> Option<PathBuf> {
|
||||
let active = std::env::var_os("VIRTUAL_ENV").map(PathBuf::from).filter(|venv| {
|
||||
crate::paths::contains(root, venv) && venv_program(venv, "python").is_some()
|
||||
});
|
||||
active.or_else(|| {
|
||||
VENV_DIR_NAMES
|
||||
.iter()
|
||||
.map(|name| root.join(name))
|
||||
.find(|venv| venv_program(venv, "python").is_some())
|
||||
})
|
||||
}
|
||||
|
||||
/// Resolve `program` for work rooted at `root`, preferring what the project installed for itself.
|
||||
///
|
||||
/// `allow_project_local` is the whole gate, and it is the caller's answer rather than this
|
||||
/// module's: a binary under `root` got there from the repository, so who is watching and what the
|
||||
/// user configured decide it, and neither is knowable here. Denied, this is exactly [`resolve`].
|
||||
pub fn resolve_in(root: &Path, program: &str, allow_project_local: bool) -> Option<PathBuf> {
|
||||
if allow_project_local {
|
||||
if let Some(local) = project_local(root, program) {
|
||||
return Some(local);
|
||||
}
|
||||
}
|
||||
resolve(program)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) mod tests;
|
||||
Reference in New Issue
Block a user