feat(maestro): load existing ACP sessions
Resume a stored ACP session through session/load and discard the history replayed during the load handshake so the durable event log remains the single transcript source.
This commit is contained in:
@@ -19,6 +19,12 @@
|
||||
//! is dropped while nobody reads: #135 takes the receiver and persists each
|
||||
//! notification to the per-session event log before broadcasting it.
|
||||
//!
|
||||
//! A respawn after a daemon restart sets [`SpawnConfig::load_session`] and
|
||||
//! the handshake runs `session/load` with the stored id instead of
|
||||
//! `session/new`. The history the agent streams back while that request is
|
||||
//! in flight is *not* delivered: the daemon's event log already holds it,
|
||||
//! and replaying it would double every line.
|
||||
//!
|
||||
//! The child is a child of the daemon, full stop. It shares the daemon's
|
||||
//! process group, is marked to receive `SIGTERM` when the daemon dies
|
||||
//! (`PR_SET_PDEATHSIG` on Linux), and [`AcpSession::terminate`] is what both
|
||||
@@ -31,13 +37,14 @@ use std::collections::{HashMap, VecDeque};
|
||||
use std::ffi::OsString;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{ExitStatus, Stdio};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
use agent_client_protocol::schema::v1::{
|
||||
CancelNotification, ClientCapabilities, FileSystemCapabilities, Implementation,
|
||||
InitializeRequest, NewSessionRequest, RequestPermissionOutcome, RequestPermissionRequest,
|
||||
RequestPermissionResponse, SessionId, SessionNotification,
|
||||
InitializeRequest, LoadSessionRequest, NewSessionRequest, RequestPermissionOutcome,
|
||||
RequestPermissionRequest, RequestPermissionResponse, SessionId, SessionNotification,
|
||||
};
|
||||
use agent_client_protocol::schema::ProtocolVersion;
|
||||
use agent_client_protocol::{ByteStreams, Client};
|
||||
@@ -82,6 +89,10 @@ pub struct SpawnConfig {
|
||||
pub env: HashMap<String, String>,
|
||||
/// Upper bound on the handshake; [`HANDSHAKE_TIMEOUT`] by default.
|
||||
pub handshake_timeout: Duration,
|
||||
/// An existing ACP session id to resume with `session/load` (#135)
|
||||
/// instead of opening a fresh one. The adapter must advertise
|
||||
/// `loadSession`; the handshake fails otherwise.
|
||||
pub load_session: Option<String>,
|
||||
}
|
||||
|
||||
impl SpawnConfig {
|
||||
@@ -90,8 +101,15 @@ impl SpawnConfig {
|
||||
cwd: cwd.into(),
|
||||
env,
|
||||
handshake_timeout: HANDSHAKE_TIMEOUT,
|
||||
load_session: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Resume `session_id` with `session/load` instead of `session/new`.
|
||||
pub fn load_session(mut self, session_id: impl Into<String>) -> Self {
|
||||
self.load_session = Some(session_id.into());
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
@@ -296,6 +314,7 @@ pub async fn spawn(config: SpawnConfig) -> Result<AcpSession, AcpError> {
|
||||
tokio::spawn(run_connection(
|
||||
transport,
|
||||
config.cwd.clone(),
|
||||
config.load_session.clone(),
|
||||
updates_tx,
|
||||
commands_rx,
|
||||
ready_tx,
|
||||
@@ -375,17 +394,28 @@ fn client_capabilities() -> ClientCapabilities {
|
||||
async fn run_connection<T>(
|
||||
transport: T,
|
||||
cwd: PathBuf,
|
||||
load_session: Option<String>,
|
||||
updates_tx: mpsc::UnboundedSender<SessionNotification>,
|
||||
mut commands_rx: mpsc::UnboundedReceiver<Command>,
|
||||
ready_tx: oneshot::Sender<Result<String, ReadyError>>,
|
||||
) where
|
||||
T: agent_client_protocol::ConnectTo<Client> + 'static,
|
||||
{
|
||||
// Set while `session/load` is in flight. Notification handlers run in
|
||||
// the dispatch loop, in arrival order, so everything the agent streams
|
||||
// before its load response sees the flag up and is dropped: that is the
|
||||
// history the event log already holds (#135).
|
||||
let replaying = Arc::new(AtomicBool::new(false));
|
||||
let replaying_seen = replaying.clone();
|
||||
let result = Client
|
||||
.builder()
|
||||
.name("maestro")
|
||||
.on_receive_notification(
|
||||
async move |notification: SessionNotification, _cx| {
|
||||
if replaying_seen.load(Ordering::SeqCst) {
|
||||
tracing::trace!("dropping replayed notification during session/load");
|
||||
return Ok(());
|
||||
}
|
||||
// A dropped receiver only means nobody wants updates any more.
|
||||
let _ = updates_tx.send(notification);
|
||||
Ok(())
|
||||
@@ -410,22 +440,45 @@ async fn run_connection<T>(
|
||||
let init = InitializeRequest::new(ProtocolVersion::V1)
|
||||
.client_capabilities(client_capabilities())
|
||||
.client_info(Implementation::new("maestro", env!("CARGO_PKG_VERSION")));
|
||||
if let Err(e) = cx.send_request(init).block_task().await {
|
||||
let _ = ready_tx.send(Err(ready_error(e)));
|
||||
return Ok(());
|
||||
}
|
||||
let created = match cx
|
||||
.send_request(NewSessionRequest::new(cwd))
|
||||
.block_task()
|
||||
.await
|
||||
{
|
||||
let initialized = match cx.send_request(init).block_task().await {
|
||||
Ok(r) => r,
|
||||
Err(e) => {
|
||||
let _ = ready_tx.send(Err(ready_error(e)));
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
let session_id = created.session_id.0.to_string();
|
||||
let session_id = match load_session {
|
||||
Some(existing) => {
|
||||
if !initialized.agent_capabilities.load_session {
|
||||
let _ = ready_tx.send(Err(ReadyError::Handshake(format!(
|
||||
"{ADAPTER_BIN} does not advertise loadSession; cannot resume session {existing}"
|
||||
))));
|
||||
return Ok(());
|
||||
}
|
||||
replaying.store(true, Ordering::SeqCst);
|
||||
let loaded = cx
|
||||
.send_request(LoadSessionRequest::new(existing.clone(), cwd))
|
||||
.block_task()
|
||||
.await;
|
||||
replaying.store(false, Ordering::SeqCst);
|
||||
if let Err(e) = loaded {
|
||||
let _ = ready_tx.send(Err(ready_error(e)));
|
||||
return Ok(());
|
||||
}
|
||||
existing
|
||||
}
|
||||
None => match cx
|
||||
.send_request(NewSessionRequest::new(cwd))
|
||||
.block_task()
|
||||
.await
|
||||
{
|
||||
Ok(created) => created.session_id.0.to_string(),
|
||||
Err(e) => {
|
||||
let _ = ready_tx.send(Err(ready_error(e)));
|
||||
return Ok(());
|
||||
}
|
||||
},
|
||||
};
|
||||
let _ = ready_tx.send(Ok(session_id.clone()));
|
||||
|
||||
loop {
|
||||
|
||||
Reference in New Issue
Block a user