feat(maestro): add maestro send for typing into a session
Adds POST /api/sessions/:id/input and a CLI command on top of it, so a script (or another agent) can hand an instruction to a running session without attaching to it. The text goes in as one write and the Enter follows 150ms later: agents that run a full-screen prompt coalesce a burst of input into a paste, and a newline inside that burst becomes a line break instead of sending the message. `--no-enter` skips the Enter and leaves the text in the prompt. The session argument takes an ID, a unique ID prefix, or a session name; names win over prefixes. A session whose pane has exited is refused (409) rather than silently accepted — unlike a stray keystroke on an attach socket, a send that goes nowhere is worth hearing about. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
766eabbcb6
commit
28778b2224
@@ -41,6 +41,9 @@ pub enum Command {
|
||||
Attach(AttachArgs),
|
||||
/// Kill a session by ID.
|
||||
Kill(KillArgs),
|
||||
/// Type text into a running session, as if it had been typed on an
|
||||
/// attached terminal.
|
||||
Send(SendArgs),
|
||||
/// Install or update the agent activity hook (#106).
|
||||
Hooks(HooksArgs),
|
||||
}
|
||||
@@ -103,6 +106,20 @@ pub struct AttachArgs {
|
||||
pub detach_key: String,
|
||||
}
|
||||
|
||||
/// `maestro send <session> <text...>`
|
||||
#[derive(Debug, clap::Args)]
|
||||
pub struct SendArgs {
|
||||
/// Session to type into: its ID, a unique ID prefix, or its name.
|
||||
pub session: String,
|
||||
/// Text to send. Omit it to read the text from stdin.
|
||||
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
|
||||
pub text: Vec<String>,
|
||||
/// Leave the text sitting in the session's prompt instead of pressing
|
||||
/// Enter after it.
|
||||
#[arg(long)]
|
||||
pub no_enter: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, clap::Args)]
|
||||
pub struct KillArgs {
|
||||
/// Session ID to kill.
|
||||
@@ -245,6 +262,40 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_send_joining_the_message_words() {
|
||||
let cli =
|
||||
Cli::try_parse_from(["maestro", "send", "planner", "run", "the", "tests"]).unwrap();
|
||||
let Command::Send(a) = cli.command else {
|
||||
panic!("expected send")
|
||||
};
|
||||
assert_eq!(a.session, "planner");
|
||||
assert_eq!(a.text, vec!["run", "the", "tests"]);
|
||||
assert!(!a.no_enter);
|
||||
}
|
||||
|
||||
/// The message is trailing_var_arg, so a word starting with `-` inside it
|
||||
/// is text, not a flag clap should reject.
|
||||
#[test]
|
||||
fn send_message_may_start_with_a_dash() {
|
||||
let cli =
|
||||
Cli::try_parse_from(["maestro", "send", "--no-enter", "planner", "--force"]).unwrap();
|
||||
let Command::Send(a) = cli.command else {
|
||||
panic!("expected send")
|
||||
};
|
||||
assert!(a.no_enter);
|
||||
assert_eq!(a.text, vec!["--force"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_text_may_be_omitted_for_stdin() {
|
||||
let cli = Cli::try_parse_from(["maestro", "send", "planner"]).unwrap();
|
||||
let Command::Send(a) = cli.command else {
|
||||
panic!("expected send")
|
||||
};
|
||||
assert!(a.text.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_env_without_equals() {
|
||||
let err = Cli::try_parse_from([
|
||||
|
||||
@@ -10,7 +10,7 @@ use maestro_protocol::DaemonClient;
|
||||
|
||||
use crate::attach::{parse_detach_key, run_attach_url};
|
||||
use crate::cli::Command;
|
||||
use crate::sessions::{run_kill, run_list, run_spawn};
|
||||
use crate::sessions::{run_kill, run_list, run_send, run_spawn};
|
||||
use maestro_config::{default_config_path, MaestroConfigFile};
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
@@ -24,6 +24,10 @@ pub enum CliError {
|
||||
Attach(#[from] crate::attach::AttachError),
|
||||
#[error("{0}")]
|
||||
Hooks(#[from] maestro_hooks::HooksError),
|
||||
#[error("{0}")]
|
||||
Resolve(#[from] crate::sessions::ResolveError),
|
||||
#[error("nothing to send: pass the text as arguments or pipe it on stdin")]
|
||||
NothingToSend,
|
||||
#[error("could not determine the home directory ($HOME unset?)")]
|
||||
NoHome,
|
||||
#[error("{0}")]
|
||||
@@ -82,6 +86,10 @@ pub async fn dispatch(
|
||||
run_kill(&daemon, &args).await?;
|
||||
println!("killed {}", args.session_id);
|
||||
}
|
||||
Command::Send(args) => {
|
||||
let id = run_send(&daemon, &args, &mut std::io::stdin()).await?;
|
||||
println!("sent to {id}");
|
||||
}
|
||||
Command::Hooks(_) => unreachable!("hooks handled before the daemon client exists"),
|
||||
}
|
||||
Ok(())
|
||||
|
||||
@@ -5,12 +5,13 @@ use std::io::Write;
|
||||
|
||||
use maestro_protocol::display::abbreviate_dir;
|
||||
use maestro_protocol::{
|
||||
ActivityState, ClientError, CreateSessionRequest, DaemonClient, DaemonInfo, Session,
|
||||
SessionStatus, WorktreeSpec,
|
||||
ActivityState, ClientError, CreateSessionRequest, DaemonClient, DaemonInfo, SendInputRequest,
|
||||
Session, SessionStatus, WorktreeSpec,
|
||||
};
|
||||
use serde_json::Value;
|
||||
|
||||
use crate::cli::{KillArgs, ListArgs, SpawnArgs};
|
||||
use crate::cli::{KillArgs, ListArgs, SendArgs, SpawnArgs};
|
||||
use crate::dispatch::CliError;
|
||||
|
||||
/// `maestro list`
|
||||
pub async fn run_list(
|
||||
@@ -66,6 +67,92 @@ pub async fn run_kill(client: &DaemonClient, args: &KillArgs) -> Result<(), Clie
|
||||
client.kill_session(args.session_id, args.force).await
|
||||
}
|
||||
|
||||
/// Nothing on the daemon answers to what the operator named.
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum ResolveError {
|
||||
#[error("no session matches {0:?} — run `maestro list` to see what is running")]
|
||||
NoMatch(String),
|
||||
#[error("{0:?} matches {1} sessions; use a session id instead")]
|
||||
Ambiguous(String, usize),
|
||||
}
|
||||
|
||||
/// Turn what the operator typed into a session id: a full ID, a unique ID
|
||||
/// prefix, or a session's name (#125), matched case-insensitively. Names come
|
||||
/// first — an operator who named a session after a hex string meant the name.
|
||||
pub fn resolve_session(sessions: &[Session], needle: &str) -> Result<uuid::Uuid, ResolveError> {
|
||||
let needle = needle.trim();
|
||||
let by_name: Vec<&Session> = sessions
|
||||
.iter()
|
||||
.filter(|s| {
|
||||
maestro_protocol::display::custom_name(s)
|
||||
.is_some_and(|n| n.eq_ignore_ascii_case(needle))
|
||||
})
|
||||
.collect();
|
||||
match by_name.len() {
|
||||
1 => return Ok(by_name[0].id),
|
||||
0 => {}
|
||||
n => return Err(ResolveError::Ambiguous(needle.to_string(), n)),
|
||||
}
|
||||
|
||||
let by_id: Vec<&Session> = sessions
|
||||
.iter()
|
||||
.filter(|s| {
|
||||
s.id.to_string()
|
||||
.to_ascii_lowercase()
|
||||
.starts_with(&needle.to_ascii_lowercase())
|
||||
})
|
||||
.collect();
|
||||
match by_id.len() {
|
||||
1 => Ok(by_id[0].id),
|
||||
0 => Err(ResolveError::NoMatch(needle.to_string())),
|
||||
n => Err(ResolveError::Ambiguous(needle.to_string(), n)),
|
||||
}
|
||||
}
|
||||
|
||||
/// `maestro send`. Answers with the session that was typed into, so the
|
||||
/// caller can name it once the daemon has accepted the text.
|
||||
///
|
||||
/// A bare ID skips the catalog fetch; anything else needs the list to match
|
||||
/// against. Text comes from the arguments, or from stdin when there is none —
|
||||
/// the shape a heredoc or a pipe wants.
|
||||
#[allow(clippy::result_large_err)]
|
||||
pub async fn run_send(
|
||||
client: &DaemonClient,
|
||||
args: &SendArgs,
|
||||
stdin: &mut impl std::io::Read,
|
||||
) -> Result<uuid::Uuid, CliError> {
|
||||
let text = if args.text.is_empty() {
|
||||
let mut buf = String::new();
|
||||
stdin.read_to_string(&mut buf)?;
|
||||
// One trailing newline is how a pipe ends, not part of the message —
|
||||
// keeping it would submit the text twice.
|
||||
buf.strip_suffix('\n')
|
||||
.map(|t| t.strip_suffix('\r').unwrap_or(t))
|
||||
.unwrap_or(&buf)
|
||||
.to_string()
|
||||
} else {
|
||||
args.text.join(" ")
|
||||
};
|
||||
if text.is_empty() {
|
||||
return Err(CliError::NothingToSend);
|
||||
}
|
||||
|
||||
let id = match uuid::Uuid::parse_str(args.session.trim()) {
|
||||
Ok(id) => id,
|
||||
Err(_) => {
|
||||
let sessions = client.list_sessions().await?;
|
||||
resolve_session(&sessions, &args.session)?
|
||||
}
|
||||
};
|
||||
|
||||
let req = SendInputRequest {
|
||||
text,
|
||||
submit: !args.no_enter,
|
||||
};
|
||||
client.send_input(id, &req).await?;
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
#[allow(clippy::write_literal)]
|
||||
fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &DaemonInfo) {
|
||||
if sessions.is_empty() {
|
||||
@@ -218,6 +305,63 @@ mod tests {
|
||||
assert!(out.contains("bash [claude]"), "{out}");
|
||||
}
|
||||
|
||||
fn named(id: u128, name: &str) -> Session {
|
||||
let mut s = session("/tmp", "claude", id);
|
||||
s.metadata
|
||||
.insert("name".into(), serde_json::Value::String(name.into()));
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolves_by_name_id_prefix_and_reports_what_it_cannot() {
|
||||
use super::{resolve_session, ResolveError};
|
||||
|
||||
// Ids that differ in their first characters, so a short prefix is
|
||||
// enough to pick one — the ergonomics the prefix match exists for.
|
||||
let (a, b) = (1u128 << 124, 2u128 << 124);
|
||||
let sessions = vec![named(a, "planner"), named(b, "builder")];
|
||||
let one = Uuid::from_u128(a);
|
||||
|
||||
assert_eq!(resolve_session(&sessions, "planner").unwrap(), one);
|
||||
// Names match case-insensitively and ignore surrounding space.
|
||||
assert_eq!(resolve_session(&sessions, " Planner ").unwrap(), one);
|
||||
// An id prefix works when it picks exactly one session.
|
||||
let prefix = &one.to_string()[..8];
|
||||
assert_eq!(resolve_session(&sessions, prefix).unwrap(), one);
|
||||
assert!(matches!(
|
||||
resolve_session(&sessions, "nope"),
|
||||
Err(ResolveError::NoMatch(_))
|
||||
));
|
||||
}
|
||||
|
||||
/// Two sessions sharing a name is legal — the daemon never enforced
|
||||
/// uniqueness — so `send` must refuse rather than pick one.
|
||||
#[test]
|
||||
fn an_ambiguous_name_is_refused() {
|
||||
use super::{resolve_session, ResolveError};
|
||||
|
||||
let sessions = vec![named(1 << 124, "worker"), named(2 << 124, "worker")];
|
||||
assert!(matches!(
|
||||
resolve_session(&sessions, "worker"),
|
||||
Err(ResolveError::Ambiguous(_, 2))
|
||||
));
|
||||
}
|
||||
|
||||
/// A session named after its own id prefix means the name: an operator
|
||||
/// who typed a name they chose should not be routed by hex coincidence.
|
||||
#[test]
|
||||
fn names_win_over_id_prefixes() {
|
||||
use super::resolve_session;
|
||||
|
||||
let two = Uuid::from_u128(2 << 124);
|
||||
let prefix = two.to_string()[..8].to_string();
|
||||
let sessions = vec![named(1 << 124, &prefix), session("/tmp", "bash", 2 << 124)];
|
||||
assert_eq!(
|
||||
resolve_session(&sessions, &prefix).unwrap(),
|
||||
Uuid::from_u128(1 << 124)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_sessions() {
|
||||
let mut buf = Vec::new();
|
||||
|
||||
@@ -108,3 +108,110 @@ async fn spawn_round_trips_through_the_daemon() {
|
||||
.expect("kill");
|
||||
assert_eq!(mock.session_count(), 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn send_types_text_and_submits_by_default() {
|
||||
let mock = MockDaemon::start().await;
|
||||
let id = Uuid::from_u128(7);
|
||||
mock.add_session(session(id, "/home/mock/work", "claude"));
|
||||
|
||||
let args = maestro_cli::cli::SendArgs {
|
||||
session: id.to_string(),
|
||||
text: vec!["run".into(), "the".into(), "tests".into()],
|
||||
no_enter: false,
|
||||
};
|
||||
let sent = maestro_cli::sessions::run_send(&mock.client(), &args, &mut std::io::empty())
|
||||
.await
|
||||
.expect("send");
|
||||
|
||||
assert_eq!(sent, id);
|
||||
let inputs = mock.inputs();
|
||||
assert_eq!(inputs.len(), 1);
|
||||
assert_eq!(inputs[0].0, id);
|
||||
assert_eq!(inputs[0].1.text, "run the tests");
|
||||
assert!(inputs[0].1.submit, "Enter is the default");
|
||||
}
|
||||
|
||||
/// `--no-enter` leaves the text in the prompt; the flag has to survive the
|
||||
/// whole way to the daemon or the message is sent anyway.
|
||||
#[tokio::test]
|
||||
async fn send_without_enter_leaves_the_text_unsubmitted() {
|
||||
let mock = MockDaemon::start().await;
|
||||
let id = Uuid::from_u128(8);
|
||||
mock.add_session(session(id, "/tmp", "bash"));
|
||||
|
||||
let args = maestro_cli::cli::SendArgs {
|
||||
session: id.to_string(),
|
||||
text: vec!["ls".into()],
|
||||
no_enter: true,
|
||||
};
|
||||
maestro_cli::sessions::run_send(&mock.client(), &args, &mut std::io::empty())
|
||||
.await
|
||||
.expect("send");
|
||||
|
||||
assert!(!mock.inputs()[0].1.submit);
|
||||
}
|
||||
|
||||
/// No text arguments → the message comes from stdin, minus the trailing
|
||||
/// newline a pipe or heredoc adds.
|
||||
#[tokio::test]
|
||||
async fn send_reads_stdin_and_drops_its_trailing_newline() {
|
||||
let mock = MockDaemon::start().await;
|
||||
let id = Uuid::from_u128(9);
|
||||
mock.add_session(session(id, "/tmp", "bash"));
|
||||
|
||||
let args = maestro_cli::cli::SendArgs {
|
||||
session: id.to_string(),
|
||||
text: Vec::new(),
|
||||
no_enter: false,
|
||||
};
|
||||
let mut stdin = std::io::Cursor::new(b"multi\nline\n".to_vec());
|
||||
maestro_cli::sessions::run_send(&mock.client(), &args, &mut stdin)
|
||||
.await
|
||||
.expect("send");
|
||||
|
||||
assert_eq!(mock.inputs()[0].1.text, "multi\nline");
|
||||
}
|
||||
|
||||
/// A session named through `PATCH /api/sessions/:id` is addressable by that
|
||||
/// name, so scripts don't have to carry a UUID around.
|
||||
#[tokio::test]
|
||||
async fn send_resolves_a_session_by_name() {
|
||||
let mock = MockDaemon::start().await;
|
||||
let id = Uuid::from_u128(10);
|
||||
let mut named = session(id, "/tmp", "claude");
|
||||
named
|
||||
.metadata
|
||||
.insert("name".into(), serde_json::Value::String("planner".into()));
|
||||
mock.add_session(named);
|
||||
mock.add_session(session(Uuid::from_u128(11), "/tmp", "bash"));
|
||||
|
||||
let args = maestro_cli::cli::SendArgs {
|
||||
session: "Planner".into(),
|
||||
text: vec!["go".into()],
|
||||
no_enter: false,
|
||||
};
|
||||
let sent = maestro_cli::sessions::run_send(&mock.client(), &args, &mut std::io::empty())
|
||||
.await
|
||||
.expect("send");
|
||||
|
||||
assert_eq!(sent, id);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn send_to_an_unknown_session_fails_without_typing_anything() {
|
||||
let mock = MockDaemon::start().await;
|
||||
mock.add_session(session(Uuid::from_u128(12), "/tmp", "bash"));
|
||||
|
||||
let args = maestro_cli::cli::SendArgs {
|
||||
session: "nope".into(),
|
||||
text: vec!["hi".into()],
|
||||
no_enter: false,
|
||||
};
|
||||
let err = maestro_cli::sessions::run_send(&mock.client(), &args, &mut std::io::empty())
|
||||
.await
|
||||
.expect_err("should not resolve");
|
||||
|
||||
assert!(err.to_string().contains("no session matches"), "{err}");
|
||||
assert!(mock.inputs().is_empty());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user