This commit is contained in:
@@ -28,7 +28,6 @@ tokio-tungstenite = { workspace = true, features = ["rustls-tls-webpki-roots"] }
|
||||
toml.workspace = true
|
||||
tracing.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
urlencoding = "2"
|
||||
uuid.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
|
||||
@@ -45,7 +45,7 @@ impl CliConfig {
|
||||
/// Load the subset of the unified file the CLI consumes. A missing file is
|
||||
/// fine — every field has a default.
|
||||
pub fn load(path: &Path) -> Result<Self, ConfigError> {
|
||||
let file = MaestroConfigFile::load_or_default(path)?;
|
||||
let file = MaestroConfigFile::load(path)?;
|
||||
Ok(Self {
|
||||
daemon_url: file.cli.daemon_url,
|
||||
daemon_bind_addr: file.daemon.bind_addr,
|
||||
|
||||
@@ -41,12 +41,6 @@ pub enum ConfigError {
|
||||
TomlEncode(#[from] toml::ser::Error),
|
||||
#[error("could not determine config directory (XDG_CONFIG_HOME / $HOME unset?)")]
|
||||
NoConfigDir,
|
||||
#[error(
|
||||
"maestro config not found at {}\n\
|
||||
Run `maestro daemon configure` to create it.",
|
||||
path.display()
|
||||
)]
|
||||
MissingFile { path: PathBuf },
|
||||
#[error("invalid {env} ({input:?}): {source}")]
|
||||
InvalidBindAddr {
|
||||
env: &'static str,
|
||||
@@ -314,27 +308,17 @@ fn validate_presets(presets: &[SpawnPreset]) -> Result<(), SpawnConfigError> {
|
||||
}
|
||||
|
||||
impl MaestroConfigFile {
|
||||
/// Strict load — error with [`ConfigError::MissingFile`] if absent.
|
||||
/// Load the file, or return an empty config if it doesn't exist. Every
|
||||
/// field has a default, so a missing file is never an error.
|
||||
pub fn load(path: &Path) -> Result<Self, ConfigError> {
|
||||
if !path.exists() {
|
||||
return Err(ConfigError::MissingFile {
|
||||
path: path.to_path_buf(),
|
||||
});
|
||||
return Ok(Self::default());
|
||||
}
|
||||
let bytes = std::fs::read(path)?;
|
||||
let s = std::str::from_utf8(&bytes).unwrap_or("");
|
||||
Ok(toml::from_str(s)?)
|
||||
}
|
||||
|
||||
/// Load if present, else return an empty config. Use for callers that
|
||||
/// want a default-on-missing read.
|
||||
pub fn load_or_default(path: &Path) -> Result<Self, ConfigError> {
|
||||
if !path.exists() {
|
||||
return Ok(Self::default());
|
||||
}
|
||||
Self::load(path)
|
||||
}
|
||||
|
||||
/// Atomic write (tmp + rename). Creates parent dirs on demand.
|
||||
pub fn save(&self, path: &Path) -> Result<(), ConfigError> {
|
||||
if let Some(parent) = path.parent() {
|
||||
@@ -447,20 +431,10 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_file_strict_load_errors_with_pointer_to_configure() {
|
||||
fn missing_file_loads_as_empty_config() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("config.toml");
|
||||
let err = MaestroConfigFile::load(&path).unwrap_err();
|
||||
let msg = err.to_string();
|
||||
assert!(matches!(err, ConfigError::MissingFile { .. }));
|
||||
assert!(msg.contains("maestro daemon configure"), "msg was: {msg}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_file_load_or_default_returns_empty() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("config.toml");
|
||||
let cfg = MaestroConfigFile::load_or_default(&path).unwrap();
|
||||
let cfg = MaestroConfigFile::load(&path).unwrap();
|
||||
assert_eq!(cfg, MaestroConfigFile::default());
|
||||
}
|
||||
|
||||
|
||||
@@ -111,7 +111,7 @@ impl EnvOverrides {
|
||||
/// Resolve the runtime configuration: env overrides on top of the unified
|
||||
/// file, then defaults. A missing file is not an error.
|
||||
pub fn load_config(path: &Path, env: EnvOverrides) -> Result<DaemonConfig, ConfigError> {
|
||||
let file = MaestroConfigFile::load_or_default(path)?;
|
||||
let file = MaestroConfigFile::load(path)?;
|
||||
|
||||
let daemon = file.daemon;
|
||||
// Resolve spawn presets up front so a bad `[spawn].presets` (empty/dup id,
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
[package]
|
||||
name = "maestro-names"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
repository.workspace = true
|
||||
publish.workspace = true
|
||||
description = "Orchestra-flavoured session-handle generator (adjective × instrument) shared across Maestro"
|
||||
|
||||
[dependencies]
|
||||
rand.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
rand = { workspace = true, features = ["small_rng"] }
|
||||
@@ -1,214 +0,0 @@
|
||||
//! `maestro-names` — the shared session-handle generator.
|
||||
//!
|
||||
//! Maestro is a conductor's podium for every shell you care about, so the
|
||||
//! handles it hands out are drawn from the orchestra pit: a musical adjective
|
||||
//! (tempo, dynamics, articulation) paired with an instrument or musical form.
|
||||
//! The result reads like a marking on a score — `allegro-cello`,
|
||||
//! `crescendo-oboe`, `staccato-viola`.
|
||||
//!
|
||||
//! ## Determinism
|
||||
//!
|
||||
//! Every pure path takes an **injected** [`rand::Rng`]; nothing here reaches
|
||||
//! for `thread_rng()` or the clock, so seeded tests are reproducible (a repo
|
||||
//! invariant). [`generate_thread`] is the one impure convenience wrapper for
|
||||
//! production callers that just want a name and don't care about the seed.
|
||||
//!
|
||||
//! The Rust generator is the source of truth. If the web UI wants an instant
|
||||
//! client-side reroll it can mirror [`ADJECTIVES`] / [`NOUNS`] verbatim, but
|
||||
//! the wordlists live here.
|
||||
|
||||
use rand::seq::SliceRandom;
|
||||
use rand::Rng;
|
||||
|
||||
/// Musical adjectives — tempo, dynamics, and articulation markings.
|
||||
pub const ADJECTIVES: &[&str] = &[
|
||||
"allegro",
|
||||
"andante",
|
||||
"adagio",
|
||||
"presto",
|
||||
"vivace",
|
||||
"largo",
|
||||
"grave",
|
||||
"lento",
|
||||
"moderato",
|
||||
"crescendo",
|
||||
"staccato",
|
||||
"legato",
|
||||
"forte",
|
||||
"dolce",
|
||||
"agitato",
|
||||
"cantabile",
|
||||
"sostenuto",
|
||||
"tremolo",
|
||||
"rubato",
|
||||
"marcato",
|
||||
"brillante",
|
||||
"maestoso",
|
||||
"grazioso",
|
||||
"espressivo",
|
||||
"tranquillo",
|
||||
"animato",
|
||||
"spirito",
|
||||
"sotto",
|
||||
"vivo",
|
||||
"feroce",
|
||||
];
|
||||
|
||||
/// Musical nouns — instruments and forms from the concert hall.
|
||||
pub const NOUNS: &[&str] = &[
|
||||
"cello", "violin", "viola", "oboe", "flute", "clarinet", "bassoon", "trumpet", "trombone",
|
||||
"tuba", "horn", "timpani", "harp", "piano", "organ", "lyre", "lute", "fugue", "sonata",
|
||||
"octave", "chord", "cadence", "prelude", "rondo", "nocturne", "scherzo", "refrain", "coda",
|
||||
"motif", "overture",
|
||||
];
|
||||
|
||||
/// Generate a single `adjective-noun` handle from an injected RNG.
|
||||
///
|
||||
/// ```
|
||||
/// use rand::SeedableRng;
|
||||
/// let mut rng = rand::rngs::SmallRng::seed_from_u64(7);
|
||||
/// let name = maestro_names::generate(&mut rng);
|
||||
/// assert!(name.contains('-'));
|
||||
/// ```
|
||||
pub fn generate<R: Rng + ?Sized>(rng: &mut R) -> String {
|
||||
// Both lists are compile-time non-empty (asserted in tests), so the
|
||||
// `choose` calls cannot return `None`.
|
||||
let adj = ADJECTIVES.choose(rng).expect("ADJECTIVES is non-empty");
|
||||
let noun = NOUNS.choose(rng).expect("NOUNS is non-empty");
|
||||
format!("{adj}-{noun}")
|
||||
}
|
||||
|
||||
/// Generate a handle that isn't already taken.
|
||||
///
|
||||
/// Draws `adjective-noun` candidates from `rng`; if `is_taken` rejects one, a
|
||||
/// numeric uniqueness suffix is appended and incremented (`-2`, `-3`, …) until
|
||||
/// a free handle is found. The bare form is preferred — the suffix only
|
||||
/// appears on collision, matching the score-marking aesthetic.
|
||||
///
|
||||
/// `is_taken` is the single source of "already used"; given the same RNG and
|
||||
/// the same predicate the output is fully deterministic.
|
||||
pub fn generate_unique<R, F>(rng: &mut R, is_taken: F) -> String
|
||||
where
|
||||
R: Rng + ?Sized,
|
||||
F: Fn(&str) -> bool,
|
||||
{
|
||||
let base = generate(rng);
|
||||
if !is_taken(&base) {
|
||||
return base;
|
||||
}
|
||||
// Start at 2 so the first duplicate reads `name`, `name-2`, `name-3` …
|
||||
for suffix in 2u64.. {
|
||||
let candidate = format!("{base}-{suffix}");
|
||||
if !is_taken(&candidate) {
|
||||
return candidate;
|
||||
}
|
||||
}
|
||||
unreachable!("u64 suffix space is effectively inexhaustible")
|
||||
}
|
||||
|
||||
/// Impure convenience wrapper: generate a handle from the thread RNG.
|
||||
///
|
||||
/// For production callers that just want a name. Tests and any deterministic
|
||||
/// path should use [`generate`] / [`generate_unique`] with a seeded RNG.
|
||||
pub fn generate_thread() -> String {
|
||||
generate(&mut rand::thread_rng())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use rand::rngs::SmallRng;
|
||||
use rand::SeedableRng;
|
||||
use std::collections::HashSet;
|
||||
|
||||
fn seeded(seed: u64) -> SmallRng {
|
||||
SmallRng::seed_from_u64(seed)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wordlists_are_non_empty() {
|
||||
assert!(!ADJECTIVES.is_empty());
|
||||
assert!(!NOUNS.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wordlists_have_no_duplicates() {
|
||||
assert_eq!(
|
||||
ADJECTIVES.iter().collect::<HashSet<_>>().len(),
|
||||
ADJECTIVES.len(),
|
||||
"duplicate adjective"
|
||||
);
|
||||
assert_eq!(
|
||||
NOUNS.iter().collect::<HashSet<_>>().len(),
|
||||
NOUNS.len(),
|
||||
"duplicate noun"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generate_is_adjective_dash_noun() {
|
||||
let mut rng = seeded(1);
|
||||
let name = generate(&mut rng);
|
||||
let (adj, noun) = name.split_once('-').expect("must contain a single dash");
|
||||
assert!(ADJECTIVES.contains(&adj), "{adj} not an adjective");
|
||||
assert!(NOUNS.contains(&noun), "{noun} not a noun");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generation_is_deterministic_under_seed() {
|
||||
// Same seed → identical sequence; this is the core repo invariant.
|
||||
let mut a = seeded(42);
|
||||
let mut b = seeded(42);
|
||||
for _ in 0..50 {
|
||||
assert_eq!(generate(&mut a), generate(&mut b));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn different_seeds_diverge() {
|
||||
// Not a guarantee for a single draw, but across a run the sequences
|
||||
// must differ — otherwise the RNG isn't actually being threaded.
|
||||
let mut a = seeded(1);
|
||||
let mut b = seeded(2);
|
||||
let seq_a: Vec<_> = (0..30).map(|_| generate(&mut a)).collect();
|
||||
let seq_b: Vec<_> = (0..30).map(|_| generate(&mut b)).collect();
|
||||
assert_ne!(seq_a, seq_b);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unique_returns_bare_name_when_free() {
|
||||
let mut rng = seeded(3);
|
||||
let name = generate_unique(&mut rng, |_| false);
|
||||
assert!(
|
||||
!name.ends_with("-2"),
|
||||
"no suffix expected when nothing taken"
|
||||
);
|
||||
assert!(name.contains('-'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unique_appends_incrementing_suffix_on_collision() {
|
||||
// Reserve the bare name and the first two suffixed variants; the
|
||||
// generator must walk past them to `-4`.
|
||||
let mut probe = seeded(9);
|
||||
let base = generate(&mut probe);
|
||||
let taken: HashSet<String> = [base.clone(), format!("{base}-2"), format!("{base}-3")]
|
||||
.into_iter()
|
||||
.collect();
|
||||
|
||||
let mut rng = seeded(9);
|
||||
let name = generate_unique(&mut rng, |n| taken.contains(n));
|
||||
assert_eq!(name, format!("{base}-4"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unique_suffix_starts_at_two() {
|
||||
let mut probe = seeded(11);
|
||||
let base = generate(&mut probe);
|
||||
let taken: HashSet<String> = [base.clone()].into_iter().collect();
|
||||
|
||||
let mut rng = seeded(11);
|
||||
let name = generate_unique(&mut rng, |n| taken.contains(n));
|
||||
assert_eq!(name, format!("{base}-2"));
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,4 @@
|
||||
//! `maestro tui` — terminal UI client over the local daemon's `/api/*` surface.
|
||||
//!
|
||||
//! Design: `docs/superpowers/specs/2026-05-28-maestro-tui-design.md`
|
||||
//! Implementation: `docs/superpowers/plans/2026-05-28-maestro-tui.md`
|
||||
|
||||
#![deny(missing_debug_implementations)]
|
||||
|
||||
@@ -74,7 +71,7 @@ pub async fn run(cfg: RunConfig) -> Result<(), TuiError> {
|
||||
maestro_config::resolve_config_path().map_err(|e| TuiError::Config(e.to_string()))
|
||||
});
|
||||
let cfg_file = match cfg_path {
|
||||
Ok(path) => maestro_config::MaestroConfigFile::load_or_default(&path)
|
||||
Ok(path) => maestro_config::MaestroConfigFile::load(&path)
|
||||
.map_err(|e| TuiError::Config(e.to_string()))?,
|
||||
Err(_) => maestro_config::MaestroConfigFile::default(),
|
||||
};
|
||||
|
||||
@@ -79,5 +79,5 @@ pnpm dev
|
||||
```
|
||||
|
||||
Vite serves on `:5173` and proxies `/api/*` straight to `maestrod` at
|
||||
`127.0.0.1:7070` (override with `MAESTRO_REGISTRY=...`). You don't need to
|
||||
`127.0.0.1:7070` (override with `MAESTRO_DAEMON_URL=...`). You don't need to
|
||||
rebuild the Rust binary while iterating on the frontend.
|
||||
|
||||
@@ -59,11 +59,7 @@ impl EnvOverrides {
|
||||
/// Resolve the runtime configuration. Missing-file is fine: every field has
|
||||
/// a default and the binary is happy to run with no config.toml at all.
|
||||
pub fn load_config(path: &Path, env: EnvOverrides) -> Result<WebConfig, WebConfigError> {
|
||||
let file = if path.exists() {
|
||||
MaestroConfigFile::load(path)?
|
||||
} else {
|
||||
MaestroConfigFile::default()
|
||||
};
|
||||
let file = MaestroConfigFile::load(path)?;
|
||||
resolve_with(file.web, env)
|
||||
}
|
||||
|
||||
|
||||
@@ -1,8 +1,5 @@
|
||||
//! `maestro-web` — standalone HTTP server that hosts the Maestro browser UI
|
||||
//! and reverse-proxies API calls to a co-located `maestrod`.
|
||||
//!
|
||||
//! See `docs/superpowers/specs/2026-05-26-connection-orchestration.md` §UI
|
||||
//! hosting for the architectural decisions.
|
||||
|
||||
#![deny(missing_debug_implementations)]
|
||||
|
||||
|
||||
Reference in New Issue
Block a user