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.
This commit is contained in:
118
crates/luxe-cli/src/cli/update_command/aside.rs
Normal file
118
crates/luxe-cli/src/cli/update_command/aside.rs
Normal file
@@ -0,0 +1,118 @@
|
||||
//! Moving the running copy aside — how `luxe update` gets out of its own way on Windows.
|
||||
//!
|
||||
//! Windows locks a running program's file against being overwritten or deleted, but not against
|
||||
//! being renamed. The running `luxe.exe` becomes `luxe.exe.old`, the owner's updater writes a new
|
||||
//! `luxe.exe`, and the next launch deletes the leftover once nothing is running from it. Nothing
|
||||
//! here writes a binary: it only renames the one that is already there.
|
||||
|
||||
use anyhow::Context;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
/// The running copy, renamed out of the way of the update.
|
||||
pub(super) struct MovedAside {
|
||||
from: PathBuf,
|
||||
to: PathBuf,
|
||||
}
|
||||
|
||||
impl MovedAside {
|
||||
/// Renames `exe` to its leftover name, clearing a leftover a previous update left behind.
|
||||
pub(super) fn move_running(exe: &Path) -> anyhow::Result<Self> {
|
||||
let to = leftover_path(exe);
|
||||
remove_if_present(&to).with_context(|| {
|
||||
format!("could not remove {}, left by an earlier update", to.display())
|
||||
})?;
|
||||
std::fs::rename(exe, &to).with_context(|| {
|
||||
format!("could not move the running {} aside to update it", exe.display())
|
||||
})?;
|
||||
Ok(Self { from: exe.to_path_buf(), to })
|
||||
}
|
||||
|
||||
/// Puts the running copy back when the update left nothing where it was, so a failed update
|
||||
/// never leaves the reader without a `luxe`.
|
||||
pub(super) fn restore_if_missing(&self) -> anyhow::Result<()> {
|
||||
if self.from.exists() {
|
||||
return Ok(());
|
||||
}
|
||||
std::fs::rename(&self.to, &self.from).with_context(|| {
|
||||
format!(
|
||||
"the update left no luxe behind and {} could not be moved back to {}",
|
||||
self.to.display(),
|
||||
self.from.display()
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Deletes the copy an earlier update moved aside, if there is one. Called at launch, when the
|
||||
/// old copy has exited. Still running elsewhere is normal (another session), so a failure is
|
||||
/// only logged and the next launch tries again.
|
||||
pub(crate) fn remove_leftover() {
|
||||
let Ok(exe) = std::env::current_exe() else { return };
|
||||
let leftover = leftover_path(&exe);
|
||||
if let Err(error) = remove_if_present(&leftover) {
|
||||
tracing::debug!(%error, path = %leftover.display(), "leftover from an update is still in use");
|
||||
}
|
||||
}
|
||||
|
||||
/// `luxe.exe` beside itself as `luxe.exe.old`.
|
||||
fn leftover_path(exe: &Path) -> PathBuf {
|
||||
let mut name = exe.file_name().unwrap_or_default().to_os_string();
|
||||
name.push(".old");
|
||||
exe.with_file_name(name)
|
||||
}
|
||||
|
||||
/// Removes `path`; already gone is success.
|
||||
fn remove_if_present(path: &Path) -> std::io::Result<()> {
|
||||
match std::fs::remove_file(path) {
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn installed() -> (tempfile::TempDir, PathBuf) {
|
||||
let dir = tempfile::tempdir().expect("tempdir");
|
||||
let exe = dir.path().join("luxe.exe");
|
||||
std::fs::write(&exe, b"old").expect("a stand-in binary");
|
||||
(dir, exe)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_leftover_sits_beside_the_binary() {
|
||||
assert_eq!(leftover_path(Path::new("/bin/luxe.exe")), PathBuf::from("/bin/luxe.exe.old"));
|
||||
}
|
||||
|
||||
/// The update writes a new file where the old one was, and the old one is left to delete.
|
||||
#[test]
|
||||
fn an_update_that_wrote_a_new_copy_keeps_it() {
|
||||
let (_dir, exe) = installed();
|
||||
let aside = MovedAside::move_running(&exe).expect("moved");
|
||||
assert!(!exe.exists(), "the name is free for the updater");
|
||||
std::fs::write(&exe, b"new").expect("the updater's copy");
|
||||
aside.restore_if_missing().expect("nothing to restore");
|
||||
assert_eq!(std::fs::read(&exe).expect("read"), b"new");
|
||||
assert_eq!(std::fs::read(leftover_path(&exe)).expect("read"), b"old");
|
||||
}
|
||||
|
||||
/// A failed update puts the running copy back rather than leaving no `luxe` at all.
|
||||
#[test]
|
||||
fn an_update_that_wrote_nothing_puts_the_old_copy_back() {
|
||||
let (_dir, exe) = installed();
|
||||
let aside = MovedAside::move_running(&exe).expect("moved");
|
||||
aside.restore_if_missing().expect("restored");
|
||||
assert_eq!(std::fs::read(&exe).expect("read"), b"old");
|
||||
assert!(!leftover_path(&exe).exists());
|
||||
}
|
||||
|
||||
/// A leftover from the last update is cleared, not a reason to refuse this one.
|
||||
#[test]
|
||||
fn a_leftover_from_last_time_is_replaced() {
|
||||
let (_dir, exe) = installed();
|
||||
std::fs::write(leftover_path(&exe), b"older").expect("a leftover");
|
||||
MovedAside::move_running(&exe).expect("moved");
|
||||
assert_eq!(std::fs::read(leftover_path(&exe)).expect("read"), b"old");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user