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>
301 lines
10 KiB
Rust
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"));
|
|
}
|
|
}
|