From f014ead3b98d13a6f1b564236dc23c94fdd515f2 Mon Sep 17 00:00:00 2001 From: Evan Whittaker Date: Sat, 17 Oct 2026 20:05:01 -0500 Subject: [PATCH] Luxe installs with curl -fsSL https://luxe.dev/install.sh | sh, edits keep a file's permissions, and the tools page charts every agent by name - luxe.dev/install.sh redirects to the latest release's installer, and luxe.dev/install.ps1 runs the release's PowerShell installer under Windows' default policy, so the commands are `curl -fsSL https://luxe.dev/install.sh | sh` and `powershell -c "irm https://luxe.dev/install.ps1 | iex"`. The install tabs run shell, brew, cargo, then windows. - The edit and write tools and format-on-save keep a file's mode, so editing a script no longer leaves it unrunnable. - The tools page gives Claude Code and Codex their own columns and bars, draws Luxe's own bar in each group, and its terminal's window controls take macOS's colors. - scripts/aur-pkgbuild.sh writes a luxe-bin PKGBUILD from a release, for the AUR once it reopens. --- README.md | 8 +- crates/luxe-cli/src/guide.md | 20 ++- crates/luxe-core/src/formatter.rs | 2 +- crates/luxe-core/src/fs_atomic.rs | 142 +++----------------- crates/luxe-core/src/fs_atomic/tests.rs | 167 ++++++++++++++++++++++++ crates/luxe-tools/src/edit.rs | 4 +- crates/luxe-tools/src/edit/tests.rs | 17 +++ crates/luxe-tools/src/write.rs | 2 +- crates/luxe-tools/src/write/tests.rs | 16 +++ docs/guide/install.md | 20 ++- scripts/aur-pkgbuild.sh | 54 ++++++++ web/public/_headers | 4 + web/public/_redirects | 6 + web/public/install.ps1 | 14 ++ web/src/components/InstallTabs.svelte | 15 +-- web/src/pages/tools.astro | 152 +++++++++++---------- 16 files changed, 420 insertions(+), 223 deletions(-) create mode 100644 crates/luxe-core/src/fs_atomic/tests.rs create mode 100755 scripts/aur-pkgbuild.sh create mode 100644 web/public/install.ps1 diff --git a/README.md b/README.md index 917c7ac..3a75b2e 100644 --- a/README.md +++ b/README.md @@ -50,16 +50,16 @@ and [the guide lists them](https://luxe.dev/docs/security/#what-luxe-sends-over- ```bash # macOS and Linux -curl --proto '=https' --tlsv1.2 -LsSf https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.sh | sh +curl -fsSL https://luxe.dev/install.sh | sh # Homebrew brew install evanwhittaker/tap/luxe -# Windows (PowerShell) -powershell -ExecutionPolicy Bypass -c "irm https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.ps1 | iex" - # Cargo (Rust 1.89 or newer) cargo install --locked luxe-cli + +# Windows (PowerShell) +powershell -c "irm https://luxe.dev/install.ps1 | iex" ``` To update, run `luxe update`. To build from source: diff --git a/crates/luxe-cli/src/guide.md b/crates/luxe-cli/src/guide.md index 2334f67..70b8501 100644 --- a/crates/luxe-cli/src/guide.md +++ b/crates/luxe-cli/src/guide.md @@ -2136,14 +2136,12 @@ On macOS and Linux, the install script puts `luxe` in `~/.local/bin`, or in `$LU when it is set, and adds that to your `PATH`: ```bash -curl --proto '=https' --tlsv1.2 -LsSf https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.sh | sh +curl -fsSL https://luxe.dev/install.sh | sh ``` -On Windows, in PowerShell: - -```powershell -powershell -ExecutionPolicy Bypass -c "irm https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.ps1 | iex" -``` +That address redirects to the script on the [latest +release](https://github.com/evanwhittaker/luxe/releases/latest), the one it built and attested. To +read it before running it, drop the `| sh`. With Homebrew, on macOS or Linux: @@ -2158,6 +2156,16 @@ one): cargo install --locked luxe-cli ``` +On Windows, in PowerShell: + +```powershell +powershell -c "irm https://luxe.dev/install.ps1 | iex" +``` + +[That script](https://luxe.dev/install.ps1) is two lines: it lets this PowerShell window run the +release's installer, which Windows' default execution policy would stop, then runs it. Nothing +about your policy is saved. + Any of them installs the `luxe` command; `luxe --version` checks it worked. To update, run `luxe update`, or `/update` inside Luxe. Luxe checks once a day for a newer release diff --git a/crates/luxe-core/src/formatter.rs b/crates/luxe-core/src/formatter.rs index 512bbb4..901fb16 100644 --- a/crates/luxe-core/src/formatter.rs +++ b/crates/luxe-core/src/formatter.rs @@ -391,7 +391,7 @@ async fn run_via_stdin(spec: &FormatterSpec, path: &Path) -> Result<(), Formatte if std::fs::read(&path)? != input { return Ok(false); } - crate::fs_atomic::replace(&path, &formatted).map(|()| true) + crate::fs_atomic::replace_keeping_mode(&path, &formatted).map(|()| true) }) .await .map_err(|error| io(spec, "write the file")(std::io::Error::other(error)))? diff --git a/crates/luxe-core/src/fs_atomic.rs b/crates/luxe-core/src/fs_atomic.rs index c26fca7..b10c0dd 100644 --- a/crates/luxe-core/src/fs_atomic.rs +++ b/crates/luxe-core/src/fs_atomic.rs @@ -62,6 +62,15 @@ pub fn replace_preserving_mode(path: &Path, bytes: &[u8]) -> io::Result<()> { replace_with_mode(path, bytes, existing_mode(path)) } +/// Replace `path` with `bytes` as an editor saves a file: one that exists keeps its mode, an +/// executable script included, and a new one gets the platform's default. +/// +/// For the user's own files, which the edit and write tools and the formatter rewrite. A rename +/// puts a new file in the old one's place, so a mode not carried over is the new file's default. +pub fn replace_keeping_mode(path: &Path, bytes: &[u8]) -> io::Result<()> { + write_then_rename(path, bytes, existing_mode(path)) +} + /// Replace `path` with `bytes` atomically but without syncing: a reader never sees half of it, and /// a power cut may lose it. /// @@ -214,10 +223,18 @@ fn open_staging(path: &Path, mode: Option) -> io::Result { let mut options = OpenOptions::new(); options.write(true).create(true).truncate(true); + // At creation too, so an owner-only file is never readable even for an instant if let Some(mode) = mode { options.mode(mode); } - options.open(path) + let file = options.open(path)?; + // A mode given at creation is filtered through the umask; set it again so the file ends up + // with exactly the mode asked for, a kept group-writable one included + if let Some(mode) = mode { + use std::os::unix::fs::PermissionsExt; + file.set_permissions(fs::Permissions::from_mode(mode))?; + } + Ok(file) } #[cfg(not(unix))] @@ -252,125 +269,4 @@ fn restrict_dir(_path: &Path) -> io::Result<()> { #[cfg(test)] #[allow(clippy::unwrap_used)] -mod tests { - use super::*; - - /// An unsynced replace still lands whole and leaves no staging file behind. - #[test] - fn an_unsynced_replace_lands_whole_and_leaves_nothing_behind() { - let dir = tempfile::tempdir().unwrap(); - let target = dir.path().join("cache").join("shard.json"); - replace_unsynced(&target, b"first").unwrap(); - replace_unsynced(&target, b"second").unwrap(); - assert_eq!(fs::read(&target).unwrap(), b"second"); - let left: Vec<_> = fs::read_dir(target.parent().unwrap()).unwrap().flatten().collect(); - assert_eq!(left.len(), 1, "only the shard: {left:?}"); - } - - /// Every directory `create_private_dir` makes is owner-only, not just the last one; one that was - /// already there keeps its mode. - #[cfg(unix)] - #[test] - fn every_directory_created_is_private() { - use std::os::unix::fs::PermissionsExt; - let mode = |path: &Path| fs::metadata(path).unwrap().permissions().mode() & 0o777; - let dir = tempfile::tempdir().unwrap(); - fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap(); - let leaf = dir.path().join("a").join("b").join("c"); - create_private_dir(&leaf).unwrap(); - for created in [dir.path().join("a"), dir.path().join("a/b"), leaf] { - assert_eq!(mode(&created), 0o700, "{}", created.display()); - } - assert_eq!(mode(dir.path()), 0o755, "an existing parent is left alone"); - } - - /// A fresh private directory refuses to adopt one that exists. - #[test] - fn a_new_private_directory_is_never_an_existing_one() { - let dir = tempfile::tempdir().unwrap(); - let fresh = dir.path().join("fresh"); - create_private_dir_new(&fresh).unwrap(); - let error = create_private_dir_new(&fresh).unwrap_err(); - assert_eq!(error.kind(), io::ErrorKind::AlreadyExists); - } - - #[test] - fn a_replacement_lands_and_leaves_no_staging_file_behind() { - let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("state.json"); - replace(&path, b"first").unwrap(); - replace(&path, b"second").unwrap(); - - assert_eq!(fs::read(&path).unwrap(), b"second"); - let strays: Vec<_> = fs::read_dir(dir.path()) - .unwrap() - .filter_map(Result::ok) - .map(|entry| entry.file_name().to_string_lossy().into_owned()) - .filter(|name| name != "state.json") - .collect(); - assert!(strays.is_empty(), "left behind: {strays:?}"); - } - - #[test] - fn missing_parents_are_created() { - let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("a").join("b").join("c.json"); - replace(&path, b"{}").unwrap(); - assert_eq!(fs::read(&path).unwrap(), b"{}"); - } - - /// The staging name has to survive a real extension, or `main.rs` and `main.md` stage to the - /// same file and the last writer wins a race nobody knew they were in. - #[test] - fn two_files_sharing_a_stem_do_not_share_a_staging_name() { - let dir = tempfile::tempdir().unwrap(); - let rust = staging_path(&dir.path().join("main.rs")); - let markdown = staging_path(&dir.path().join("main.md")); - assert_ne!(rust, markdown); - assert_eq!(rust.parent(), Some(dir.path()), "staging stays on the target's filesystem"); - } - - /// Two writers of the *same* file must not collide on the staging name either — one would - /// truncate the other's half-written bytes and then rename them into place. - #[test] - fn concurrent_writers_of_one_file_get_distinct_staging_names() { - let path = Path::new("/tmp/luxe/thing.json"); - assert_ne!(staging_path(path), staging_path(path)); - } - - #[cfg(unix)] - #[test] - fn a_private_replacement_is_owner_only_from_the_moment_it_exists() { - use std::os::unix::fs::PermissionsExt; - let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("auth.json"); - replace_private(&path, b"secret").unwrap(); - assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600); - - let nested = dir.path().join("private"); - create_private_dir(&nested).unwrap(); - assert_eq!(fs::metadata(&nested).unwrap().permissions().mode() & 0o777, 0o700); - } - - /// A failed write must not leave a stray staging file, and must not damage what was there. - #[test] - fn a_failure_leaves_the_previous_contents_alone() { - let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("kept.json"); - replace(&path, b"original").unwrap(); - - // A directory in the target's place: the rename cannot succeed. - let blocked = dir.path().join("blocked.json"); - fs::create_dir(&blocked).unwrap(); - assert!(replace(&blocked, b"nope").is_err()); - - assert_eq!(fs::read(&path).unwrap(), b"original"); - let strays: Vec<_> = fs::read_dir(dir.path()) - .unwrap() - .filter_map(Result::ok) - .map(|entry| entry.file_name().to_string_lossy().into_owned()) - .filter(|name| name.ends_with(".tmp")) - .collect(); - assert!(strays.is_empty(), "left behind: {strays:?}"); - } -} +mod tests; diff --git a/crates/luxe-core/src/fs_atomic/tests.rs b/crates/luxe-core/src/fs_atomic/tests.rs new file mode 100644 index 0000000..2d75c9e --- /dev/null +++ b/crates/luxe-core/src/fs_atomic/tests.rs @@ -0,0 +1,167 @@ +use super::*; + +#[cfg(unix)] +fn mode_of(path: &Path) -> u32 { + use std::os::unix::fs::PermissionsExt; + fs::metadata(path).unwrap().permissions().mode() & 0o777 +} + +/// Editing a script keeps it a script. The rename puts a new file where the old one was, so a +/// mode not carried over is lost: every edit of an executable left it unrunnable. +#[cfg(unix)] +#[test] +fn a_replace_keeping_mode_leaves_a_script_executable() { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let script = dir.path().join("run.sh"); + fs::write(&script, b"#!/bin/sh\n").unwrap(); + fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap(); + replace_keeping_mode(&script, b"#!/bin/sh\necho hi\n").unwrap(); + assert_eq!(mode_of(&script), 0o755); + assert_eq!(fs::read(&script).unwrap(), b"#!/bin/sh\necho hi\n"); +} + +/// The mode kept is the mode the file had, bit for bit, not one the umask trimmed on the way. +#[cfg(unix)] +#[test] +fn a_kept_mode_is_exact_whatever_the_umask() { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let shared = dir.path().join("shared"); + fs::write(&shared, b"a").unwrap(); + // World-writable on purpose: any umask that is not 000 strips at least one of these bits + fs::set_permissions(&shared, fs::Permissions::from_mode(0o777)).unwrap(); + replace_keeping_mode(&shared, b"b").unwrap(); + assert_eq!(mode_of(&shared), 0o777); +} + +/// A file that did not exist gets the mode any new file would, not the owner-only one secrets get. +#[cfg(unix)] +#[test] +fn a_new_file_kept_mode_gets_the_ordinary_default() { + let dir = tempfile::tempdir().unwrap(); + let ordinary = dir.path().join("ordinary"); + File::create(&ordinary).unwrap(); + let fresh = dir.path().join("fresh"); + replace_keeping_mode(&fresh, b"new").unwrap(); + assert_eq!(mode_of(&fresh), mode_of(&ordinary)); +} + +/// An unsynced replace still lands whole and leaves no staging file behind. +#[test] +fn an_unsynced_replace_lands_whole_and_leaves_nothing_behind() { + let dir = tempfile::tempdir().unwrap(); + let target = dir.path().join("cache").join("shard.json"); + replace_unsynced(&target, b"first").unwrap(); + replace_unsynced(&target, b"second").unwrap(); + assert_eq!(fs::read(&target).unwrap(), b"second"); + let left: Vec<_> = fs::read_dir(target.parent().unwrap()).unwrap().flatten().collect(); + assert_eq!(left.len(), 1, "only the shard: {left:?}"); +} + +/// Every directory `create_private_dir` makes is owner-only, not just the last one; one that was +/// already there keeps its mode. +#[cfg(unix)] +#[test] +fn every_directory_created_is_private() { + use std::os::unix::fs::PermissionsExt; + let mode = |path: &Path| fs::metadata(path).unwrap().permissions().mode() & 0o777; + let dir = tempfile::tempdir().unwrap(); + fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap(); + let leaf = dir.path().join("a").join("b").join("c"); + create_private_dir(&leaf).unwrap(); + for created in [dir.path().join("a"), dir.path().join("a/b"), leaf] { + assert_eq!(mode(&created), 0o700, "{}", created.display()); + } + assert_eq!(mode(dir.path()), 0o755, "an existing parent is left alone"); +} + +/// A fresh private directory refuses to adopt one that exists. +#[test] +fn a_new_private_directory_is_never_an_existing_one() { + let dir = tempfile::tempdir().unwrap(); + let fresh = dir.path().join("fresh"); + create_private_dir_new(&fresh).unwrap(); + let error = create_private_dir_new(&fresh).unwrap_err(); + assert_eq!(error.kind(), io::ErrorKind::AlreadyExists); +} + +#[test] +fn a_replacement_lands_and_leaves_no_staging_file_behind() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("state.json"); + replace(&path, b"first").unwrap(); + replace(&path, b"second").unwrap(); + + assert_eq!(fs::read(&path).unwrap(), b"second"); + let strays: Vec<_> = fs::read_dir(dir.path()) + .unwrap() + .filter_map(Result::ok) + .map(|entry| entry.file_name().to_string_lossy().into_owned()) + .filter(|name| name != "state.json") + .collect(); + assert!(strays.is_empty(), "left behind: {strays:?}"); +} + +#[test] +fn missing_parents_are_created() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("a").join("b").join("c.json"); + replace(&path, b"{}").unwrap(); + assert_eq!(fs::read(&path).unwrap(), b"{}"); +} + +/// The staging name has to survive a real extension, or `main.rs` and `main.md` stage to the +/// same file and the last writer wins a race nobody knew they were in. +#[test] +fn two_files_sharing_a_stem_do_not_share_a_staging_name() { + let dir = tempfile::tempdir().unwrap(); + let rust = staging_path(&dir.path().join("main.rs")); + let markdown = staging_path(&dir.path().join("main.md")); + assert_ne!(rust, markdown); + assert_eq!(rust.parent(), Some(dir.path()), "staging stays on the target's filesystem"); +} + +/// Two writers of the *same* file must not collide on the staging name either — one would +/// truncate the other's half-written bytes and then rename them into place. +#[test] +fn concurrent_writers_of_one_file_get_distinct_staging_names() { + let path = Path::new("/tmp/luxe/thing.json"); + assert_ne!(staging_path(path), staging_path(path)); +} + +#[cfg(unix)] +#[test] +fn a_private_replacement_is_owner_only_from_the_moment_it_exists() { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("auth.json"); + replace_private(&path, b"secret").unwrap(); + assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600); + + let nested = dir.path().join("private"); + create_private_dir(&nested).unwrap(); + assert_eq!(fs::metadata(&nested).unwrap().permissions().mode() & 0o777, 0o700); +} + +/// A failed write must not leave a stray staging file, and must not damage what was there. +#[test] +fn a_failure_leaves_the_previous_contents_alone() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("kept.json"); + replace(&path, b"original").unwrap(); + + // A directory in the target's place: the rename cannot succeed. + let blocked = dir.path().join("blocked.json"); + fs::create_dir(&blocked).unwrap(); + assert!(replace(&blocked, b"nope").is_err()); + + assert_eq!(fs::read(&path).unwrap(), b"original"); + let strays: Vec<_> = fs::read_dir(dir.path()) + .unwrap() + .filter_map(Result::ok) + .map(|entry| entry.file_name().to_string_lossy().into_owned()) + .filter(|name| name.ends_with(".tmp")) + .collect(); + assert!(strays.is_empty(), "left behind: {strays:?}"); +} diff --git a/crates/luxe-tools/src/edit.rs b/crates/luxe-tools/src/edit.rs index 6c34aac..546bac1 100644 --- a/crates/luxe-tools/src/edit.rs +++ b/crates/luxe-tools/src/edit.rs @@ -428,7 +428,9 @@ impl Tool for EditTool { let diff = crate::diff_preview::ranges_diff(&content, &preview); let result = apply(&content, &planned); - if let Err(problem) = luxe_core::fs_atomic::replace(&full_path, result.as_bytes()) { + if let Err(problem) = + luxe_core::fs_atomic::replace_keeping_mode(&full_path, result.as_bytes()) + { warn!(path = %full_path.display(), error = %problem, "failed to write edited file"); return ToolResultData::error(format!( "Error writing file '{}': {problem}", diff --git a/crates/luxe-tools/src/edit/tests.rs b/crates/luxe-tools/src/edit/tests.rs index 63cc172..26a4657 100644 --- a/crates/luxe-tools/src/edit/tests.rs +++ b/crates/luxe-tools/src/edit/tests.rs @@ -78,6 +78,23 @@ async fn a_reformatted_edit_shows_the_file_as_it_is_now() { assert!(text.contains("+1 fn b() {}"), "{text}"); } +/// An edited script stays executable. Saving by rename replaced the file with a new one at the +/// default mode, so every edit of a script left it unrunnable. +#[cfg(unix)] +#[tokio::test] +async fn an_edited_script_stays_executable() { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let script = dir.path().join("run.sh"); + std::fs::write(&script, "#!/bin/sh\necho one\n").unwrap(); + std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap(); + let args = json!({"path": "run.sh", "edits": [{"oldText": "one", "newText": "two"}]}); + let result = EditTool::new().run(args, &test_context(dir.path())).await; + assert!(!result.is_error, "{:?}", result.content); + let mode = std::fs::metadata(&script).unwrap().permissions().mode() & 0o777; + assert_eq!(mode, 0o755, "still executable after the edit"); +} + #[tokio::test] async fn edit_tool_basic() { let tmp_dir_guard = tempfile::tempdir().expect("temp dir"); diff --git a/crates/luxe-tools/src/write.rs b/crates/luxe-tools/src/write.rs index ff8c755..d5da4ca 100644 --- a/crates/luxe-tools/src/write.rs +++ b/crates/luxe-tools/src/write.rs @@ -182,7 +182,7 @@ impl Tool for WriteTool { Err(_) => std::borrow::Cow::Borrowed(content), }; - match luxe_core::fs_atomic::replace(&full_path, content.as_bytes()) { + match luxe_core::fs_atomic::replace_keeping_mode(&full_path, content.as_bytes()) { Ok(()) => { debug!(path = %full_path.display(), "file written successfully"); self.after_write(cx, &full_path, &content, existed).await diff --git a/crates/luxe-tools/src/write/tests.rs b/crates/luxe-tools/src/write/tests.rs index a90c072..a423326 100644 --- a/crates/luxe-tools/src/write/tests.rs +++ b/crates/luxe-tools/src/write/tests.rs @@ -30,6 +30,22 @@ async fn a_reformatted_write_shows_the_file_as_it_is_now() { assert!(text.contains("+1 fn sub(a: i32) {}") && !text.contains("a:i32"), "{text}"); } +/// Overwriting a script keeps it executable, as an editor's save does. +#[cfg(unix)] +#[tokio::test] +async fn an_overwritten_script_stays_executable() { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let script = dir.path().join("run.sh"); + std::fs::write(&script, "#!/bin/sh\n").unwrap(); + std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap(); + let args = serde_json::json!({"path": "run.sh", "content": "#!/bin/sh\necho hi\n"}); + let result = WriteTool::new().run(args, &test_context(dir.path())).await; + assert!(!result.is_error, "{:?}", result.content); + let mode = std::fs::metadata(&script).unwrap().permissions().mode() & 0o777; + assert_eq!(mode, 0o755, "still executable after the write"); +} + #[tokio::test] async fn write_tool_basic() { let tmp_dir_guard = tempfile::tempdir().expect("temp dir"); diff --git a/docs/guide/install.md b/docs/guide/install.md index 6a791ee..05354ef 100644 --- a/docs/guide/install.md +++ b/docs/guide/install.md @@ -11,14 +11,12 @@ On macOS and Linux, the install script puts `luxe` in `~/.local/bin`, or in `$LU when it is set, and adds that to your `PATH`: ```bash -curl --proto '=https' --tlsv1.2 -LsSf https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.sh | sh +curl -fsSL https://luxe.dev/install.sh | sh ``` -On Windows, in PowerShell: - -```powershell -powershell -ExecutionPolicy Bypass -c "irm https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.ps1 | iex" -``` +That address redirects to the script on the [latest +release](https://github.com/evanwhittaker/luxe/releases/latest), the one it built and attested. To +read it before running it, drop the `| sh`. With Homebrew, on macOS or Linux: @@ -33,6 +31,16 @@ one): cargo install --locked luxe-cli ``` +On Windows, in PowerShell: + +```powershell +powershell -c "irm https://luxe.dev/install.ps1 | iex" +``` + +[That script](https://luxe.dev/install.ps1) is two lines: it lets this PowerShell window run the +release's installer, which Windows' default execution policy would stop, then runs it. Nothing +about your policy is saved. + Any of them installs the `luxe` command; `luxe --version` checks it worked. To update, run `luxe update`, or `/update` inside Luxe. Luxe checks once a day for a newer release diff --git a/scripts/aur-pkgbuild.sh b/scripts/aur-pkgbuild.sh new file mode 100755 index 0000000..071d1eb --- /dev/null +++ b/scripts/aur-pkgbuild.sh @@ -0,0 +1,54 @@ +#!/usr/bin/env bash +# aur-pkgbuild — writes the PKGBUILD for the `luxe-bin` AUR package from a release. +# +# Usage: scripts/aur-pkgbuild.sh [out-dir] e.g. scripts/aur-pkgbuild.sh 0.1.0 /tmp/aur +# +# `luxe-bin` repackages the release's own Linux archives, checked against the release's `.sha256` +# files, so it ships exactly what the release built and attested. It installs to /usr/bin, which +# `luxe update` reads as a package manager's copy and leaves to pacman. The updater the install +# script adds is left out for the same reason. Generate .SRCINFO from the result with +# `makepkg --printsrcinfo > .SRCINFO`. +set -euo pipefail + +version="${1:?usage: aur-pkgbuild.sh [out-dir]}" +out="${2:-.}" +release="https://github.com/evanwhittaker/luxe/releases/download/v${version}" + +# The release's own checksum for one target's archive +checksum() { + curl -fsSL "${release}/luxe-cli-$1-unknown-linux-gnu.tar.xz.sha256" | cut -d' ' -f1 +} +x86_64="$(checksum x86_64)" +aarch64="$(checksum aarch64)" + +mkdir -p "${out}" +cat >"${out}/PKGBUILD" < +# Generated by scripts/aur-pkgbuild.sh in https://github.com/evanwhittaker/luxe + +pkgname=luxe-bin +pkgver=${version} +pkgrel=1 +pkgdesc="A terminal coding agent: streaming chat, tools, guided diff review, and LSP/DAP code intelligence" +arch=('x86_64' 'aarch64') +url="https://luxe.dev" +license=('MIT' 'Apache-2.0') +depends=('gcc-libs' 'glibc') +provides=('luxe') +conflicts=('luxe') +# The release's binary as it was built and attested: not stripped again, no debug split +options=('!strip' '!debug') +source_x86_64=("luxe-cli-x86_64-\${pkgver}.tar.xz::https://github.com/evanwhittaker/luxe/releases/download/v\${pkgver}/luxe-cli-x86_64-unknown-linux-gnu.tar.xz") +source_aarch64=("luxe-cli-aarch64-\${pkgver}.tar.xz::https://github.com/evanwhittaker/luxe/releases/download/v\${pkgver}/luxe-cli-aarch64-unknown-linux-gnu.tar.xz") +sha256sums_x86_64=('${x86_64}') +sha256sums_aarch64=('${aarch64}') + +package() { + cd "luxe-cli-\${CARCH}-unknown-linux-gnu" + install -Dm755 luxe "\${pkgdir}/usr/bin/luxe" + install -Dm644 LICENSE-MIT "\${pkgdir}/usr/share/licenses/\${pkgname}/LICENSE-MIT" + install -Dm644 LICENSE-APACHE "\${pkgdir}/usr/share/licenses/\${pkgname}/LICENSE-APACHE" + install -Dm644 README.md "\${pkgdir}/usr/share/doc/\${pkgname}/README.md" +} +PKGBUILD +echo "wrote ${out}/PKGBUILD for luxe-bin ${version}" diff --git a/web/public/_headers b/web/public/_headers index 4368d71..2b9456a 100644 --- a/web/public/_headers +++ b/web/public/_headers @@ -24,6 +24,10 @@ Content-Type: text/plain; charset=utf-8 Access-Control-Allow-Origin: * +# Text, so `irm` hands `iex` a script rather than bytes +/install.ps1 + Content-Type: text/plain; charset=utf-8 + /* Cache-Control: public, max-age=0, must-revalidate X-Content-Type-Options: nosniff diff --git a/web/public/_redirects b/web/public/_redirects index ff0c96f..677451a 100644 --- a/web/public/_redirects +++ b/web/public/_redirects @@ -3,3 +3,9 @@ # The themes page folded into the homepage's gallery; a link to it lands on the gallery. /themes /#craft 301 /themes/ /#craft 301 + +# The install script, at an address short enough to read: `curl -fsSL https://luxe.dev/install.sh | sh`. +# It redirects to the latest release's own script, so luxe.dev never holds a copy that could drift +# from what the release built and attested. 302, not 301: "latest" moves, so nothing may cache it. +# /install.ps1 is a file instead (public/install.ps1): Windows needs a line run before the installer. +/install.sh https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.sh 302 diff --git a/web/public/install.ps1 b/web/public/install.ps1 new file mode 100644 index 0000000..ff5d0ca --- /dev/null +++ b/web/public/install.ps1 @@ -0,0 +1,14 @@ +# Luxe's installer for Windows: +# +# powershell -c "irm https://luxe.dev/install.ps1 | iex" +# +# The installer each release ships refuses to run under Windows' default execution policy, which is +# why its own instructions pass `-ExecutionPolicy ByPass`. This does the same for this PowerShell +# process alone, with nothing saved and no admin needed, then runs the latest release's installer, +# so the address never holds an installer that could drift from what the release built. +# +# A policy set by Group Policy outranks the process scope, as it outranks the command-line flag. +# Setting it then fails, and that is let pass: where the enforced policy allows the installer it runs +# anyway, and where it does not, the installer's own check says so and how to fix it. +Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force -ErrorAction SilentlyContinue +Invoke-RestMethod 'https://github.com/evanwhittaker/luxe/releases/latest/download/luxe-cli-installer.ps1' | Invoke-Expression diff --git a/web/src/components/InstallTabs.svelte b/web/src/components/InstallTabs.svelte index d28fb49..9e7af91 100644 --- a/web/src/components/InstallTabs.svelte +++ b/web/src/components/InstallTabs.svelte @@ -3,20 +3,13 @@ type Channel = { id: string; label: string; command: string; note?: string }; - const releases = "https://github.com/evanwhittaker/luxe/releases/latest/download"; + // Most likely reader first. install.sh redirects to the latest release's script and install.ps1 + // runs it (web/public/_redirects, web/public/install.ps1) const channels: Channel[] = [ - { - id: "shell", - label: "shell", - command: `curl --proto '=https' --tlsv1.2 -LsSf ${releases}/luxe-cli-installer.sh | sh`, - }, + { id: "shell", label: "shell", command: "curl -fsSL https://luxe.dev/install.sh | sh" }, { id: "brew", label: "brew", command: "brew install evanwhittaker/tap/luxe" }, - { - id: "windows", - label: "windows", - command: `powershell -ExecutionPolicy Bypass -c "irm ${releases}/luxe-cli-installer.ps1 | iex"`, - }, { id: "cargo", label: "cargo", command: "cargo install --locked luxe-cli" }, + { id: "windows", label: "windows", command: 'powershell -c "irm https://luxe.dev/install.ps1 | iex"' }, ]; let active = $state(channels[0]); diff --git a/web/src/pages/tools.astro b/web/src/pages/tools.astro index 1f994e3..35e5724 100644 --- a/web/src/pages/tools.astro +++ b/web/src/pages/tools.astro @@ -269,20 +269,20 @@ type CostRow = { model: string; luxe: { passed: number; runs: number } } & Parti Record<"claude" | "codex" | "opencode", Other> >; const costRows = agentCost.rows as CostRow[]; -const vendorAgent = (row: CostRow) => row.claude ?? row.codex; const multiple = (other?: Other) => (other ? `${other.cold.toFixed(2)}×` : "–"); -/** The chart's scale: the costliest multiple, rounded up to a half, so 1× (Luxe) sits at a fixed mark. */ -const chartScale = - Math.ceil( - Math.max(...costRows.flatMap((row) => [vendorAgent(row)?.cold ?? 0, row.opencode?.cold ?? 0])) * 2, - ) / 2; -const chartWidth = (multiple: number) => `${(multiple / chartScale) * 100}%`; +/** Each model's bars: Luxe at 1×, then every agent that ran it. A vendor's agent runs only its own + * vendor's models, so a model has Claude Code's bar or Codex's, never both. */ const chartBars = (row: CostRow) => [ - { kind: "vendor", other: vendorAgent(row) }, - { kind: "opencode", other: row.opencode }, - ].flatMap(({ kind, other }) => (other ? [{ kind, cold: other.cold }] : [])); + { kind: "luxe", label: "Luxe", cold: 1 }, + { kind: "claude", label: "Claude Code", cold: row.claude?.cold }, + { kind: "codex", label: "Codex", cold: row.codex?.cold }, + { kind: "opencode", label: "OpenCode", cold: row.opencode?.cold }, + ].flatMap((bar) => (bar.cold === undefined ? [] : [{ ...bar, cold: bar.cold }])); +/** The chart's scale: the costliest multiple, rounded up to a half. */ +const chartScale = Math.ceil(Math.max(...costRows.flatMap(chartBars).map((bar) => bar.cold)) * 2) / 2; +const chartWidth = (multiple: number) => `${(multiple / chartScale) * 100}%`; /** A bar's share of its row, never so thin it disappears. */ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, 0.6)}%`; @@ -361,11 +361,15 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100,

+ {/* The table and its note are one column, so the note sits under what it qualifies rather + than below whichever of table and chart runs longer */} +
- + + @@ -376,26 +380,33 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, - + + )) }
ModelClaude Code or CodexClaude CodeCodex OpenCode
{row.model} {multiple(vendorAgent(row))}{multiple(row.claude)}{multiple(row.codex)} {multiple(row.opencode)}
+

+ Every run is charged as a cold start, the way a session begins after a break. Run side by + side on a warm cache, Claude Code and OpenCode cost up to 2.6× what Luxe does on Claude + models. Claude Code runs only Claude models and Codex only OpenAI's, hence the dashes. + Pass rates overlapped on every model. Graded on one machine rather than in + SWE-bench's own containers, so these are not leaderboard scores. Measured at + {agentCost.commit}. +

+
{/* The table's numbers drawn; hidden from screen readers, which have the table */} -
-
-

- Every run is charged as a cold start, the way a session begins after a break. Run side - by side on a warm cache, Claude Code and OpenCode cost up to 2.6× what Luxe does on - Claude models. Pass rates overlapped on every model. Graded on one machine rather than in SWE-bench's own containers, so these are not leaderboard - scores. Measured at {agentCost.commit}. -

-
{ @@ -567,6 +570,18 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, font-weight: 500; } + /* Four columns fit a phone only with less air between them */ + @media (max-width: 40rem) { + .costs { + font-size: var(--step--1); + } + + .costs th, + .costs td { + padding: var(--space-2); + } + } + .group__name { font-size: var(--step-2); margin-bottom: var(--space-5); @@ -622,6 +637,13 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, .split--tasks .costs { margin-top: 0; + width: 100%; + } + + /* As wide as the table it qualifies, and no wider than a line should be */ + .tasks__note { + max-width: var(--measure); + margin: var(--space-4) 0 0; } /* === The head's terminal === */ @@ -647,12 +669,22 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, gap: 0.4em; } + /* macOS's window controls, in its own colors: close, minimize, zoom. Literal rather than theme + tokens, since they draw a Mac window rather than Luxe */ .terminal__dots i { display: inline-block; - width: 0.6em; - height: 0.6em; + width: 0.7em; + height: 0.7em; border-radius: 50%; - background: var(--luxe-dim); + background: #ff5f57; + } + + .terminal__dots i:nth-child(2) { + background: #febc2e; + } + + .terminal__dots i:nth-child(3) { + background: #28c840; } .terminal__body { @@ -706,36 +738,10 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, font-size: var(--step--1); } - .chart__legend { - display: flex; - flex-wrap: wrap; - gap: var(--space-2) var(--space-4); + .chart__caption { color: var(--luxe-muted); } - .chart__key::before { - content: ""; - display: inline-block; - width: 0.8em; - height: 0.8em; - margin-right: 0.5em; - vertical-align: -0.05em; - } - - .chart__key--vendor::before { - background: var(--luxe-dim); - } - - .chart__key--opencode::before { - background: var(--luxe-muted); - } - - .chart__key--luxe::before { - width: 2px; - height: 1em; - background: var(--luxe-accent); - } - .chart__group { display: grid; gap: 0.3em; @@ -745,36 +751,42 @@ const share = (shell: number, tool: number) => `${Math.max((tool / shell) * 100, color: var(--luxe-accent); } + /* Each bar says whose it is, so no legend is needed to read it */ .chart__row { display: grid; - grid-template-columns: minmax(0, 1fr) 4rem; + grid-template-columns: 7.5rem minmax(0, 1fr) 4rem; align-items: center; gap: var(--space-3); } + .chart__agent { + color: var(--luxe-muted); + white-space: nowrap; + } + + .chart__row--luxe .chart__agent, + .chart__row--luxe .chart__value { + color: var(--luxe-accent); + } + .chart__track { position: relative; height: 0.9rem; background: var(--luxe-user-msg-bg); } - /* Luxe's 1×, drawn through every row: each bar is read against it */ - .chart__track::after { - content: ""; - position: absolute; - top: -0.2rem; - bottom: -0.2rem; - left: var(--one); - width: 2px; - background: var(--luxe-accent); - } - .chart__bar { display: block; height: 100%; } - .chart__row--vendor .chart__bar { + .chart__row--luxe .chart__bar { + background: var(--luxe-accent); + } + + /* A vendor's own agent; Claude Code and Codex never share a model, so they share a shade */ + .chart__row--claude .chart__bar, + .chart__row--codex .chart__bar { background: var(--luxe-dim); }