This repository has been archived on 2026-10-08. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
maestro/crates/maestro-daemon/src/configure.rs
T
naps62-yoloandClaude Opus 4.8 b5fabff8e4 feat(maestro): durable per-host spawn history + recent-dirs query (#24)
Add a `spawn_history` daemon module backing the spawn form's "recent dirs"
picker. Sidecars are deleted on kill, so they can't be the source — use an
append-only JSONL log at `<state_dir>/spawn-history.jsonl`, one record per
successful spawn (cwd, command, name, worktree_branch, at).

- Write: `SessionManager::create` appends after a successful spawn,
  best-effort — a log-write failure only warns, never fails the spawn.
- Read: `recent_dirs()` folds newest-first, dedups by cwd, drops entries past
  the recency cap, caps the result count.
- Prune: opportunistic `compact()` from `append` once the file passes a size
  threshold; atomic tmp+rename rewrite.
- Config: `[daemon].spawn_history_days` (default 30, `0` disables). History is
  wired into the manager at daemon startup.

Time-dependent logic is factored into `*_as_of(now)` helpers for
deterministic unit tests. Adds module unit tests (append/dedup/recency
prune/compaction/disabled/malformed/cap), a config resolution test, and
real-tmux integration tests proving create→append→read end to end.

Closes #24

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-20 20:54:21 +00:00

301 lines
10 KiB
Rust

//! `maestrod configure` — interactive + flag-driven config bootstrap.
//!
//! Writes the unified Maestro config file at `~/.config/maestro/config.toml`
//! (or `$MAESTRO_CONFIG`) from a mix of CLI flags and (when stdin is a TTY)
//! prompts. Refuses to overwrite an existing file unless `--force` is passed.
//!
//! With `--force`, the daemon-relevant sections (`[shared]` and `[daemon]`)
//! are rewritten, but any `[cli]` / `[registry]` sections already in the file
//! are preserved.
use std::io::{self, BufRead, IsTerminal, Write};
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use maestro_config::{DaemonSection, MaestroConfigFile, SharedSection};
use crate::config::{system_hostname, ConfigError, DEFAULT_BIND_ADDR};
#[derive(Debug, thiserror::Error)]
pub enum ConfigureError {
#[error("config: {0}")]
Config(#[from] ConfigError),
#[error("io: {0}")]
Io(#[from] io::Error),
#[error("invalid bind_addr {input:?}: {source}")]
InvalidBindAddr {
input: String,
source: std::net::AddrParseError,
},
#[error("{path:?} already exists — pass --force to overwrite")]
AlreadyExists { path: PathBuf },
#[error(
"missing required field(s) in non-interactive mode: {missing} \
(pass via flags or run interactively)"
)]
MissingRequired { missing: String },
}
/// User-supplied inputs from flags. `None` means "not given on the CLI";
/// the configurator will prompt or default depending on context.
#[derive(Debug, Default, Clone)]
pub struct ConfigureInputs {
pub registry_url: Option<String>,
pub daemon_url: Option<String>,
pub token: Option<String>,
pub daemon_id: Option<String>,
pub bind_addr: Option<String>,
pub state_dir: Option<PathBuf>,
pub worktree_root: Option<PathBuf>,
pub hostname: Option<String>,
}
/// Run `maestrod configure`. Writes the file at `path` (creating parents).
///
/// `interactive` controls prompt behaviour:
/// - `true` → prompt for any required field that's missing from `inputs`.
/// - `false` → error out instead (used in scripts / containers).
///
/// Returns the path that was written.
pub fn run(
path: &Path,
inputs: ConfigureInputs,
interactive: bool,
force: bool,
) -> Result<PathBuf, ConfigureError> {
if path.exists() && !force {
return Err(ConfigureError::AlreadyExists {
path: path.to_path_buf(),
});
}
let stdin = io::stdin();
let stdout = io::stdout();
let mut handle = stdout.lock();
let interactive_ok = interactive && stdin.is_terminal();
let registry_url = resolve_required(
"registry_url",
"Registry base URL (e.g. https://maestro.example.com)",
inputs.registry_url,
&mut handle,
&stdin,
interactive_ok,
)?;
let daemon_url = resolve_required(
"daemon_url",
"Reachable URL for this daemon (e.g. ws://laptop.tail-abc.ts.net:7070)",
inputs.daemon_url,
&mut handle,
&stdin,
interactive_ok,
)?;
let token = resolve_required(
"token",
"Shared token (MAESTRO_TOKEN; paste from the registry)",
inputs.token,
&mut handle,
&stdin,
interactive_ok,
)?;
let host = inputs.hostname.unwrap_or_else(system_hostname);
let daemon_id = inputs.daemon_id.unwrap_or_else(|| host.clone());
let bind_addr = match inputs.bind_addr.as_deref() {
Some(raw) => Some(parse_bind_addr(raw)?),
None => None,
};
// Read-modify-write: preserve `[cli]` / `[registry]` sections that may
// already exist (e.g. on a host that runs both the registry and the
// daemon, or one that's been used as a CLI client).
let mut file = MaestroConfigFile::load_or_default(path).map_err(ConfigError::from)?;
file.shared = SharedSection {
registry_url: Some(registry_url),
token: Some(token),
};
file.daemon = DaemonSection {
daemon_id: Some(daemon_id),
hostname: Some(host),
daemon_url: Some(daemon_url),
bind_addr,
state_dir: inputs.state_dir,
worktree_root: inputs.worktree_root,
// `maestrod configure` doesn't prompt for perimeter fields yet — those
// are operator-edited in config.toml directly. Leave None on bootstrap.
perimeter_id: None,
private_addr: None,
// None ⇒ daemon falls back to pty::DEFAULT_REPLAY_BYTES. Override in
// config.toml as `[daemon] pty_replay_bytes = ...` (NAP-229).
pty_replay_bytes: None,
// None ⇒ daemon resolves to $XDG_RUNTIME_DIR at startup. Override in
// config.toml as `[daemon] tmux_tmpdir = "/tmp"` (NAP-234).
tmux_tmpdir: None,
// None ⇒ daemon defaults to DEFAULT_SPAWN_HISTORY_DAYS (30). Override
// in config.toml as `[daemon] spawn_history_days = 0` to disable (#24).
spawn_history_days: None,
};
file.save(path).map_err(ConfigError::from)?;
let _ = handle; // stdout handle only used during prompts; binary prints "wrote ..."
Ok(path.to_path_buf())
}
fn resolve_required(
field: &'static str,
prompt: &str,
provided: Option<String>,
out: &mut impl Write,
stdin: &io::Stdin,
interactive_ok: bool,
) -> Result<String, ConfigureError> {
if let Some(v) = provided.filter(|v| !v.is_empty()) {
return Ok(v);
}
if !interactive_ok {
return Err(ConfigureError::MissingRequired {
missing: field.to_string(),
});
}
write!(out, "{prompt}: ")?;
out.flush()?;
let mut line = String::new();
stdin.lock().read_line(&mut line)?;
let trimmed = line.trim().to_string();
if trimmed.is_empty() {
return Err(ConfigureError::MissingRequired {
missing: field.to_string(),
});
}
Ok(trimmed)
}
fn parse_bind_addr(raw: &str) -> Result<SocketAddr, ConfigureError> {
raw.parse()
.map_err(|source| ConfigureError::InvalidBindAddr {
input: raw.to_string(),
source,
})
}
/// Suggest a sensible default bind address. Currently `DEFAULT_BIND_ADDR`
/// from `config.rs`; here so callers don't import both modules.
pub fn default_bind_addr_hint() -> &'static str {
DEFAULT_BIND_ADDR
}
#[cfg(test)]
mod tests {
use super::*;
fn full_inputs() -> ConfigureInputs {
ConfigureInputs {
registry_url: Some("https://reg.example".into()),
daemon_url: Some("ws://localhost:7070".into()),
token: Some("secret".into()),
daemon_id: Some("laptop".into()),
bind_addr: Some("0.0.0.0:7070".into()),
state_dir: None,
worktree_root: None,
hostname: Some("laptop.lan".into()),
}
}
#[test]
fn non_interactive_with_full_flags_writes_unified_file() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
run(&path, full_inputs(), false, false).unwrap();
let written = MaestroConfigFile::load(&path).unwrap();
assert_eq!(
written.shared.registry_url.as_deref(),
Some("https://reg.example")
);
assert_eq!(written.shared.token.as_deref(), Some("secret"));
assert_eq!(written.daemon.daemon_id.as_deref(), Some("laptop"));
assert_eq!(
written.daemon.bind_addr.unwrap().to_string(),
"0.0.0.0:7070"
);
}
#[test]
fn non_interactive_missing_required_errors() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
let mut inputs = full_inputs();
inputs.token = None;
let err = run(&path, inputs, false, false).unwrap_err();
match err {
ConfigureError::MissingRequired { missing } => assert_eq!(missing, "token"),
other => panic!("expected MissingRequired(token), got {other:?}"),
}
assert!(!path.exists());
}
#[test]
fn refuses_to_overwrite_without_force() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "existing").unwrap();
let err = run(&path, full_inputs(), false, false).unwrap_err();
assert!(matches!(err, ConfigureError::AlreadyExists { .. }));
// file untouched
assert_eq!(std::fs::read_to_string(&path).unwrap(), "existing");
}
#[test]
fn force_preserves_unrelated_sections() {
// Existing file has [cli] (set by the user) and [registry] (set by
// a co-located registry on the same host). `configure --force`
// should overwrite [shared] + [daemon] but leave those alone.
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(
&path,
r#"
[cli]
cookie = "keep-me"
[registry]
bind_addr = "0.0.0.0:8080"
"#,
)
.unwrap();
run(&path, full_inputs(), false, true).unwrap();
let written = MaestroConfigFile::load(&path).unwrap();
assert_eq!(written.shared.token.as_deref(), Some("secret"));
assert_eq!(written.cli.cookie.as_deref(), Some("keep-me"));
assert_eq!(
written.registry.bind_addr,
Some("0.0.0.0:8080".parse().unwrap())
);
}
#[test]
fn invalid_bind_addr_flag_errors() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
let mut inputs = full_inputs();
inputs.bind_addr = Some("nope".into());
let err = run(&path, inputs, false, false).unwrap_err();
assert!(matches!(err, ConfigureError::InvalidBindAddr { .. }));
}
#[test]
fn daemon_id_defaults_to_hostname_when_neither_given() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
let inputs = ConfigureInputs {
registry_url: Some("http://r".into()),
daemon_url: Some("ws://x".into()),
token: Some("t".into()),
hostname: Some("override-host".into()),
..ConfigureInputs::default()
};
run(&path, inputs, false, false).unwrap();
let written = MaestroConfigFile::load(&path).unwrap();
assert_eq!(written.daemon.daemon_id.as_deref(), Some("override-host"));
assert_eq!(written.daemon.hostname.as_deref(), Some("override-host"));
}
}