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.
2026-10-20 02:40:13 -05:00
|
|
|
//! `luxe remote setup` — from nothing to a paired phone, asking before each step that changes
|
2026-10-20 13:51:34 -05:00
|
|
|
//! something outside luxe.
|
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.
2026-10-20 02:40:13 -05:00
|
|
|
//!
|
|
|
|
|
//! 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?") {
|
2026-10-20 13:51:34 -05:00
|
|
|
outln!("Skipped. Run `luxe remote` yourself whenever your devices should reach luxe.");
|
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.
2026-10-20 02:40:13 -05:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|