diff --git a/crates/maestro-protocol/src/display.rs b/crates/maestro-protocol/src/display.rs index b967b78..fe2deda 100644 --- a/crates/maestro-protocol/src/display.rs +++ b/crates/maestro-protocol/src/display.rs @@ -5,7 +5,7 @@ use std::path::{Path, PathBuf}; -use crate::Session; +use crate::{NameSource, Session}; /// The name a session was given (#125), if any. `None` for one that was never /// renamed — clients fall back to the command. @@ -16,6 +16,23 @@ pub fn custom_name(s: &Session) -> Option<&str> { } } +/// Where [`custom_name`] came from (#131). A session carrying no +/// `name_source` — one named before the field existed — reads as +/// [`NameSource::User`], so an existing name is never treated as provisional. +pub fn name_source(s: &Session) -> NameSource { + match s.metadata.get(crate::NAME_SOURCE_KEY) { + Some(serde_json::Value::String(source)) => NameSource::from_wire(source), + _ => NameSource::default(), + } +} + +/// Whether the card should render its name as provisional (#131): a generated +/// handle the daemon may still replace with one derived from the first +/// prompt. Both sidebars dim exactly this (docs/SIDEBAR.md). +pub fn is_provisional_name(s: &Session) -> bool { + custom_name(s).is_some() && name_source(s) == NameSource::Generated +} + /// Collapse a daemon's home dir to `~`. `home` empty leaves the path /// untouched. Mirrors the web's `abbreviateCwd`. pub fn abbreviate_dir(path: &Path, home: &str) -> String { @@ -234,6 +251,56 @@ mod tests { } } + /// #131: a session named before `name_source` existed reads as `User`, + /// so an existing name is never dimmed or overwritten. + #[test] + fn a_name_without_a_source_is_a_user_name() { + let mut s = session("/home/u/p"); + s.metadata.insert( + crate::NAME_KEY.into(), + serde_json::Value::String("amber-falcon".into()), + ); + assert_eq!(name_source(&s), NameSource::User); + assert!(!is_provisional_name(&s)); + } + + /// Only a generated handle is provisional; a haiku-derived name has + /// settled and renders like any other (#131). + #[test] + fn only_a_generated_name_is_provisional() { + let mut s = session("/home/u/p"); + s.metadata.insert( + crate::NAME_KEY.into(), + serde_json::Value::String("amber-falcon".into()), + ); + for (stored, source, provisional) in [ + ("Generated", NameSource::Generated, true), + ("Haiku", NameSource::Haiku, false), + ("User", NameSource::User, false), + // A spelling from a newer daemon degrades to the settled variant. + ("Something", NameSource::User, false), + ] { + s.metadata.insert( + crate::NAME_SOURCE_KEY.into(), + serde_json::Value::String(stored.into()), + ); + assert_eq!(name_source(&s), source, "{stored}"); + assert_eq!(is_provisional_name(&s), provisional, "{stored}"); + } + } + + /// A source with no name behind it is not something to dim — the card is + /// showing its command. + #[test] + fn a_source_without_a_name_is_not_provisional() { + let mut s = session("/home/u/p"); + s.metadata.insert( + crate::NAME_SOURCE_KEY.into(), + serde_json::Value::String("Generated".into()), + ); + assert!(!is_provisional_name(&s)); + } + #[test] fn abbreviate_dir_collapses_home() { assert_eq!( diff --git a/crates/maestro-protocol/src/lib.rs b/crates/maestro-protocol/src/lib.rs index 406b978..3281a06 100644 --- a/crates/maestro-protocol/src/lib.rs +++ b/crates/maestro-protocol/src/lib.rs @@ -573,6 +573,75 @@ fn submit_default() -> bool { true } +/// Metadata key holding a session's name (#125). +pub const NAME_KEY: &str = "name"; + +/// Metadata key holding where that name came from (#131). +pub const NAME_SOURCE_KEY: &str = "name_source"; + +/// Where a session's [`NAME_KEY`] came from (#131), and so whether a client +/// renders it as settled or provisional. +/// +/// Deserializes leniently, like [`ActivityState`]: an unknown spelling from a +/// newer daemon reads as [`NameSource::User`], the settled variant. A name +/// wrongly painted as settled is only a missed dimming; one wrongly painted +/// as provisional invites the daemon to overwrite a name a person chose. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Default)] +pub enum NameSource { + /// Typed by a person — in the spawn form, or through a rename. Never + /// overwritten by autonaming. The forward-compatible default, so a + /// session named by a client that predates this field is left alone. + #[default] + User, + /// The daemon's own random handle, assigned because the spawn request + /// carried no name. Provisional: rendered dimmed, and the only source + /// autonaming will replace. + Generated, + /// Derived from the session's first prompt (#131). Settled — a second + /// prompt does not rename the session again. + Haiku, +} + +impl<'de> Deserialize<'de> for NameSource { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let s = String::deserialize(deserializer)?; + Ok(Self::from_wire(&s)) + } +} + +impl NameSource { + /// Read a stored spelling, leniently: anything unrecognised is + /// [`NameSource::User`]. + pub fn from_wire(s: &str) -> Self { + match s { + "Generated" => Self::Generated, + "Haiku" => Self::Haiku, + _ => Self::User, + } + } + + /// The spelling stored in `metadata`. + pub fn as_str(self) -> &'static str { + match self { + Self::User => "User", + Self::Generated => "Generated", + Self::Haiku => "Haiku", + } + } +} + +/// HTTP `POST /api/sessions/:id/prompt` body (#131): the first prompt an +/// agent running in the session received. Agent-agnostic — Claude Code posts +/// it from a `UserPromptSubmit` hook, and any other agent's hook writes the +/// same shape. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct SessionPromptRequest { + pub prompt: String, +} + /// Longest session name the daemon stores (#125), in characters. A name is a /// sidebar card's line 1; past this it only truncates on every client anyway. pub const MAX_SESSION_NAME_LEN: usize = 64; @@ -1068,6 +1137,33 @@ mod tests { assert_eq!(capped.chars().count(), MAX_SESSION_NAME_LEN); } + /// #131: the prompt body round-trips whatever the agent sent, quotes and + /// newlines included — the hook posts its payload verbatim rather than + /// building JSON in shell. + #[test] + fn prompt_request_round_trips_awkward_text() { + let req = SessionPromptRequest { + prompt: "fix \"the\" parser\nthen run tests".into(), + }; + assert_eq!(req, round_trip(&req)); + } + + /// The stored spelling and the parse of it agree, and anything else is + /// the settled default (#131). + #[test] + fn name_source_spellings_round_trip_and_degrade_to_user() { + for source in [NameSource::User, NameSource::Generated, NameSource::Haiku] { + assert_eq!(NameSource::from_wire(source.as_str()), source); + assert_eq!( + serde_json::to_value(source).unwrap(), + serde_json::Value::String(source.as_str().into()) + ); + assert_eq!(round_trip(&source), source); + } + assert_eq!(NameSource::from_wire("Rolled"), NameSource::User); + assert_eq!(NameSource::default(), NameSource::User); + } + #[test] fn rename_request_round_trips() { let req = RenameSessionRequest { diff --git a/crates/maestro-protocol/src/routes.rs b/crates/maestro-protocol/src/routes.rs index 9cf1dec..d7990a7 100644 --- a/crates/maestro-protocol/src/routes.rs +++ b/crates/maestro-protocol/src/routes.rs @@ -49,6 +49,12 @@ pub fn session_activity(id: Uuid) -> String { format!("{SESSIONS}/{id}/activity") } +/// `POST /api/sessions/:id/prompt` (#131): an agent reports the prompt it was +/// just given, so the daemon can name the session after the first one. +pub fn session_prompt(id: Uuid) -> String { + format!("{SESSIONS}/{id}/prompt") +} + /// `POST /api/sessions/:id/input`: type text into a session's pane. pub fn session_input(id: Uuid) -> String { format!("{SESSIONS}/{id}/input") @@ -65,6 +71,7 @@ pub mod patterns { pub const SESSION: &str = "/api/sessions/:id"; pub const SESSION_ACTIVITY: &str = "/api/sessions/:id/activity"; pub const SESSION_INPUT: &str = "/api/sessions/:id/input"; + pub const SESSION_PROMPT: &str = "/api/sessions/:id/prompt"; pub const ATTACH: &str = "/api/attach/:id"; } @@ -180,6 +187,10 @@ mod tests { session_input(id()), "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/input" ); + assert_eq!( + session_prompt(id()), + "/api/sessions/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50/prompt" + ); assert_eq!( attach(id()), "/api/attach/6f1a7c0e-0f5e-4a2b-9a3d-6b1c2d3e4f50" @@ -206,6 +217,10 @@ mod tests { patterns::SESSION_INPUT.trim_end_matches(":id/input"), session(id()).trim_end_matches(&id().to_string()) ); + assert_eq!( + patterns::SESSION_PROMPT.trim_end_matches(":id/prompt"), + session(id()).trim_end_matches(&id().to_string()) + ); assert_eq!( patterns::ATTACH.trim_end_matches(":id"), attach(id()).trim_end_matches(&id().to_string())