Luxe 0.1.3: your sessions on your phone, joinable sessions, and nested AGENTS.md
- luxe remote puts the sessions on your computer in reach of your own phone or tablet over Tailscale: write, steer, answer prompts, send photos, browse files, diffs and GitHub, with a paired device and your own Tailscale login. - luxe join lets another program on the same machine join a running session over the RPC protocol. - An AGENTS.md in a subfolder reaches the model the first time it works there. - Long sessions stay fast: no stall before each model call, lighter memory, cheaper drawing. - A session is open in one Luxe at a time, web_search shares results across its phrasings, and a grep glob starting with ! excludes. The CHANGELOG has the full list.
This commit is contained in:
172
crates/luxe-cli/src/cli/remote_command/setup.rs
Normal file
172
crates/luxe-cli/src/cli/remote_command/setup.rs
Normal file
@@ -0,0 +1,172 @@
|
||||
//! `luxe remote setup` — from nothing to a paired phone, asking before each step that changes
|
||||
//! something outside Luxe.
|
||||
//!
|
||||
//! Four steps: Tailscale is there and signed in; Serve carries `https://<this machine>/` to the
|
||||
//! bridge; a user service runs the bridge at login; and an invitation to scan. Each step that is
|
||||
//! already done says so and moves on, so running setup again is how to check it.
|
||||
|
||||
use std::io::{BufRead, IsTerminal, Write};
|
||||
use std::path::PathBuf;
|
||||
|
||||
use luxe_remote::service::Launch;
|
||||
use luxe_remote::{DeviceBook, Published, Tailnet, TailnetError};
|
||||
|
||||
use crate::output::{out, outln};
|
||||
|
||||
/// Runs every step in order. Only a missing or signed-out Tailscale stops it.
|
||||
pub(super) async fn setup(
|
||||
port: u16,
|
||||
allow: Vec<String>,
|
||||
devices: &DeviceBook,
|
||||
) -> anyhow::Result<()> {
|
||||
let tailnet = check_tailscale().await?;
|
||||
publish_step(port, &tailnet).await;
|
||||
service_step(port, &tailnet, allow);
|
||||
wait_for_bridge(port).await;
|
||||
outln!();
|
||||
super::invitation::show(port, devices, &tailnet)
|
||||
}
|
||||
|
||||
/// Gives a service that just started up to two seconds to bind its port.
|
||||
async fn wait_for_bridge(port: u16) {
|
||||
for _ in 0..10 {
|
||||
if super::invitation::bridge_listening(port) {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn check_tailscale() -> anyhow::Result<Tailnet> {
|
||||
match luxe_remote::this_machine().await {
|
||||
Ok(tailnet) => {
|
||||
outln!("Tailscale: signed in as {} on {}.", tailnet.login, tailnet.dns_name);
|
||||
Ok(tailnet)
|
||||
}
|
||||
Err(error) => {
|
||||
outln!("{}", tailscale_advice(&error));
|
||||
Err(error.into())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn tailscale_advice(error: &TailnetError) -> &'static str {
|
||||
match error {
|
||||
TailnetError::NotInstalled => {
|
||||
"Install Tailscale from https://tailscale.com/download and sign in, then run \
|
||||
`luxe remote setup` again."
|
||||
}
|
||||
TailnetError::NotRunning(_) => {
|
||||
"Sign in to Tailscale with `tailscale up`, then run `luxe remote setup` again."
|
||||
}
|
||||
TailnetError::Failed(_) | TailnetError::Unreadable(_) => {
|
||||
"Check that Tailscale is running with `tailscale status`, then run `luxe remote setup` \
|
||||
again."
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn publish_step(port: u16, tailnet: &Tailnet) {
|
||||
let address = format!("https://{}/", tailnet.dns_name);
|
||||
match luxe_remote::published(port).await {
|
||||
Ok(Published::Here) => outln!("Serve: {address} leads to the bridge."),
|
||||
Ok(Published::Elsewhere(target)) => outln!(
|
||||
"Serve: {address} already leads to {target}, so setup leaves it alone. \
|
||||
`tailscale serve --bg {port}` would point it at the bridge instead."
|
||||
),
|
||||
Ok(Published::Nowhere) => offer_publish(port, &address).await,
|
||||
Err(error) => outln!("Serve: couldn't read its settings ({error})."),
|
||||
}
|
||||
}
|
||||
|
||||
async fn offer_publish(port: u16, address: &str) {
|
||||
let question = format!("Publish the bridge at {address}, for your tailnet only?");
|
||||
if !confirm(&question) {
|
||||
outln!("Skipped. `tailscale serve --bg {port}` publishes it when you're ready.");
|
||||
return;
|
||||
}
|
||||
match luxe_remote::publish(port).await {
|
||||
Ok(()) => outln!("Serve: {address} now leads to the bridge."),
|
||||
Err(error) => {
|
||||
outln!("Serve: {error}");
|
||||
outln!("{}", SERVE_HINT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What usually stops `tailscale serve` for an ordinary account.
|
||||
const SERVE_HINT: &str = if cfg!(target_os = "linux") {
|
||||
"If it said access denied, let your account manage Tailscale with \
|
||||
`sudo tailscale set --operator=$USER`, then run setup again."
|
||||
} else {
|
||||
"Fix what Tailscale said above, then run setup again."
|
||||
};
|
||||
|
||||
fn service_step(port: u16, tailnet: &Tailnet, allow: Vec<String>) {
|
||||
if luxe_remote::service::installed() {
|
||||
outln!("Service: installed, so the bridge runs whenever you're signed in.");
|
||||
return;
|
||||
}
|
||||
if !confirm("Run the bridge whenever you're signed in, as a user service?") {
|
||||
outln!("Skipped. Run `luxe remote` yourself whenever your devices should reach Luxe.");
|
||||
return;
|
||||
}
|
||||
let launch =
|
||||
Launch { program: luxe_program(), args: service_args(port, &tailnet.login, allow) };
|
||||
match luxe_remote::service::install(&launch) {
|
||||
Ok(recorded) => outln!("Service: installed ({recorded}) and started."),
|
||||
Err(error) => outln!("Service: {error}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// The bridge's flags as the service runs it, the owner named outright so the service doesn't
|
||||
/// depend on reaching Tailscale as it starts.
|
||||
fn service_args(port: u16, owner: &str, allow: Vec<String>) -> Vec<String> {
|
||||
let mut args = vec!["remote".into(), "--port".into(), port.to_string()];
|
||||
for login in std::iter::once(owner.to_string()).chain(allow) {
|
||||
args.extend(["--allow".into(), login]);
|
||||
}
|
||||
args
|
||||
}
|
||||
|
||||
/// This binary, by the path on `PATH` when that is the same file, since an upgrade replaces the
|
||||
/// file a package manager links from `PATH` and leaves a versioned path behind.
|
||||
fn luxe_program() -> PathBuf {
|
||||
let running = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("luxe"));
|
||||
let on_path = luxe_core::program::resolve("luxe");
|
||||
let same = |path: &PathBuf| path.canonicalize().ok() == running.canonicalize().ok();
|
||||
on_path.filter(same).unwrap_or(running)
|
||||
}
|
||||
|
||||
/// Asks a yes-or-no question, yes by default. Without a terminal to ask, the answer is no.
|
||||
fn confirm(question: &str) -> bool {
|
||||
if !std::io::stdin().is_terminal() {
|
||||
outln!("{question} Not asked, with no terminal to answer in.");
|
||||
return false;
|
||||
}
|
||||
out!("{question} [Y/n] ");
|
||||
let _ = std::io::stdout().flush();
|
||||
let mut answer = String::new();
|
||||
if std::io::stdin().lock().read_line(&mut answer).is_err() {
|
||||
return false;
|
||||
}
|
||||
let answer = answer.trim().to_lowercase();
|
||||
answer.is_empty() || answer.starts_with('y')
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The service names the owner and every `--allow`, on the port setup was given.
|
||||
///
|
||||
/// The break this catches: a service that relies on finding Tailscale as it starts, which
|
||||
/// launchd's bare `PATH` doesn't, so the bridge comes up letting nobody in.
|
||||
#[test]
|
||||
fn the_service_names_who_it_lets_in() {
|
||||
let args = service_args(4600, "alex@github", vec!["sam@github".into()]);
|
||||
let expected =
|
||||
["remote", "--port", "4600", "--allow", "alex@github", "--allow", "sam@github"];
|
||||
assert_eq!(args, expected);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user