feat(maestro): forced kill ends the session and retains the worktree
--force overrides the kill refusal and nothing else (#81). The guarded worktree is recorded in the retained store with reason force-killed — never removed — and the outcome names what was kept so a client can say where the work went. A tree whose guard is clear never needed the override; force removes it as usual. The store write happens before teardown, so a failed retention leaves the session running and every artifact intact. DELETE /api/sessions/:id takes ?force=true and answers 200 with KillOutcome; the unforced kill keeps its 204.
This commit is contained in:
@@ -56,6 +56,9 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
|
||||
Some(p) => Tmux::new().with_tmpdir(p),
|
||||
None => Tmux::new(),
|
||||
};
|
||||
let retained = std::sync::Arc::new(crate::retained_store::RetainedStore::new(
|
||||
config.retained_worktree_dir(),
|
||||
));
|
||||
let manager = SessionManager::new_with_replay(
|
||||
std::sync::Arc::new(tmux),
|
||||
sidecar,
|
||||
@@ -66,7 +69,10 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
|
||||
.with_spawn_history(crate::spawn_history::SpawnHistory::new(
|
||||
config.spawn_history_path(),
|
||||
config.spawn_history_days,
|
||||
));
|
||||
))
|
||||
// One store instance shared with the API handlers: forced kills (#81)
|
||||
// record here, `GET /api/worktrees` (#80) reads back from here.
|
||||
.with_retained_store((*retained).clone());
|
||||
|
||||
let recovered = manager.recover().await?;
|
||||
tracing::info!(recovered, "adopted existing tmux sessions");
|
||||
@@ -85,9 +91,7 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
|
||||
config.home_dir.clone(),
|
||||
config.spawn_presets.clone(),
|
||||
projects,
|
||||
std::sync::Arc::new(crate::retained_store::RetainedStore::new(
|
||||
config.retained_worktree_dir(),
|
||||
)),
|
||||
retained,
|
||||
));
|
||||
|
||||
let listener = TcpListener::bind(config.bind_addr).await?;
|
||||
|
||||
@@ -101,6 +101,8 @@ fn session_error_status(code: &str) -> StatusCode {
|
||||
"invalid_env" => StatusCode::BAD_REQUEST,
|
||||
// A guard refusal is the daemon doing its job, not a failure (#79).
|
||||
"kill_guarded" => StatusCode::CONFLICT,
|
||||
// The retention record failed before anything was torn down (#81).
|
||||
"retain_failed" => StatusCode::INTERNAL_SERVER_ERROR,
|
||||
_ => StatusCode::BAD_GATEWAY,
|
||||
}
|
||||
}
|
||||
@@ -179,9 +181,29 @@ async fn create_session(
|
||||
/// The full error info is passed through rather than rebuilt from
|
||||
/// code + message: a `kill_guarded` refusal (#79) carries the unsaved-work
|
||||
/// breakdown clients render as "3 uncommitted files, 2 unpushed commits".
|
||||
async fn kill_session(State(s): State<LocalApiState>, Path(id): Path<Uuid>) -> Response {
|
||||
match s.manager.kill(id).await {
|
||||
Ok(()) => StatusCode::NO_CONTENT.into_response(),
|
||||
///
|
||||
/// With `force=true` (#81) the refusal is overridden and the worktree
|
||||
/// retained; the answer is `200` with a [`KillOutcome`] naming what was kept.
|
||||
/// Without it the historical `204` stands.
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct KillQuery {
|
||||
#[serde(default)]
|
||||
force: bool,
|
||||
}
|
||||
|
||||
async fn kill_session(
|
||||
State(s): State<LocalApiState>,
|
||||
Path(id): Path<Uuid>,
|
||||
Query(q): Query<KillQuery>,
|
||||
) -> Response {
|
||||
match s.manager.kill(id, q.force).await {
|
||||
Ok(outcome) => {
|
||||
if q.force {
|
||||
(StatusCode::OK, Json(outcome)).into_response()
|
||||
} else {
|
||||
StatusCode::NO_CONTENT.into_response()
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
let info = e.to_error_info();
|
||||
let status = session_error_status(&info.code);
|
||||
|
||||
@@ -12,8 +12,8 @@ use std::time::Duration;
|
||||
|
||||
use chrono::Utc;
|
||||
use maestro_protocol::{
|
||||
ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, Session, SessionStatus,
|
||||
WorktreeSpec,
|
||||
ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, KillOutcome, RetainedReason,
|
||||
RetainedWorktree, Session, SessionStatus, WorktreeSpec,
|
||||
};
|
||||
use tokio::sync::{broadcast, Mutex};
|
||||
use uuid::Uuid;
|
||||
@@ -44,6 +44,11 @@ pub struct SessionRecord {
|
||||
/// `base_repo` from the original `WorktreeSpec`. Needed because `git
|
||||
/// worktree remove` is invoked from the base repo.
|
||||
pub worktree_base_repo: Option<PathBuf>,
|
||||
/// Branch the worktree was created for, recorded at spawn time so a
|
||||
/// forced kill (#81) can name it in the retained store without asking
|
||||
/// git. Sessions adopted from a sidecar have no branch on record and
|
||||
/// fall back to a probe.
|
||||
pub worktree_branch: Option<String>,
|
||||
pub bridge: PtyBridge,
|
||||
}
|
||||
|
||||
@@ -66,6 +71,11 @@ pub enum SessionError {
|
||||
/// so it stays the operator's handle on their own unfinished work.
|
||||
#[error("kill refused: the session's worktree holds unsaved work ({0})")]
|
||||
KillGuarded(maestro_protocol::InTheWay),
|
||||
/// A forced kill (#81) records the retained worktree *before* tearing
|
||||
/// anything down; if that write fails nothing was destroyed, and the
|
||||
/// error says so rather than silently dropping unrecorded work.
|
||||
#[error("could not record the retained worktree: {0}")]
|
||||
RetainFailed(String),
|
||||
}
|
||||
|
||||
impl SessionError {
|
||||
@@ -78,6 +88,7 @@ impl SessionError {
|
||||
SessionError::NotFound(_) => "not_found",
|
||||
SessionError::InvalidEnv(_) => "invalid_env",
|
||||
SessionError::KillGuarded(_) => "kill_guarded",
|
||||
SessionError::RetainFailed(_) => "retain_failed",
|
||||
};
|
||||
let unsaved_work = match self {
|
||||
SessionError::KillGuarded(b) => Some(*b),
|
||||
@@ -110,6 +121,9 @@ struct Inner {
|
||||
/// `None` when not wired (tests, or before `with_spawn_history`); a present
|
||||
/// but disabled (`0`-day) history no-ops internally.
|
||||
spawn_history: Option<SpawnHistory>,
|
||||
/// Retained-worktree store (#78). `None` when not wired (tests); a forced
|
||||
/// kill (#81) without one fails rather than destroying unrecorded work.
|
||||
retained: Option<crate::retained_store::RetainedStore>,
|
||||
sessions: Mutex<HashMap<Uuid, SessionRecord>>,
|
||||
events: broadcast::Sender<CatalogEvent>,
|
||||
}
|
||||
@@ -148,6 +162,7 @@ impl SessionManager {
|
||||
fifo_dir,
|
||||
replay_bytes,
|
||||
spawn_history: None,
|
||||
retained: None,
|
||||
sessions: Mutex::new(HashMap::new()),
|
||||
events,
|
||||
}),
|
||||
@@ -170,6 +185,16 @@ impl SessionManager {
|
||||
self
|
||||
}
|
||||
|
||||
/// Attach the retained-worktree store (#78). A forced kill (#81) needs it
|
||||
/// to record what it retained; without one, forcing a guarded kill fails
|
||||
/// instead of destroying unrecorded work.
|
||||
pub fn with_retained_store(mut self, store: crate::retained_store::RetainedStore) -> Self {
|
||||
let inner = Arc::get_mut(&mut self.inner)
|
||||
.expect("with_retained_store must be called before the SessionManager is cloned");
|
||||
inner.retained = Some(store);
|
||||
self
|
||||
}
|
||||
|
||||
/// Recent working dirs for the spawn form's picker (#24), newest-first and
|
||||
/// deduped by dir. Empty when no history is wired or it's disabled.
|
||||
pub fn recent_dirs(&self) -> Vec<RecentDir> {
|
||||
@@ -340,6 +365,7 @@ impl SessionManager {
|
||||
fifo_path,
|
||||
worktree_path,
|
||||
worktree_base_repo,
|
||||
worktree_branch: req.worktree.as_ref().map(|w| w.branch.clone()),
|
||||
bridge,
|
||||
},
|
||||
);
|
||||
@@ -391,11 +417,17 @@ impl SessionManager {
|
||||
/// work, so ending a session that still matters becomes a deliberate
|
||||
/// `--force`, which retains rather than destroys (WORKTREES.md).
|
||||
///
|
||||
/// With `force` (#81) the refusal — and nothing else — is overridden:
|
||||
/// the session ends and the guarded worktree is retained into the store
|
||||
/// with reason `force-killed`, never removed. The outcome names what was
|
||||
/// kept so a client can say where the work went. A tree whose guard is
|
||||
/// clear never needed the override; force removes it as usual.
|
||||
///
|
||||
/// This is also how an already-dead session is dismissed. tmux is only
|
||||
/// asked to kill something it still has — calling `kill-session` on a
|
||||
/// session tmux already lost fails, and that failure is not interesting.
|
||||
pub async fn kill(&self, id: Uuid) -> Result<(), SessionError> {
|
||||
let (worktree, alive) = {
|
||||
pub async fn kill(&self, id: Uuid, force: bool) -> Result<KillOutcome, SessionError> {
|
||||
let (worktree, alive, known_branch) = {
|
||||
let sessions = self.inner.sessions.lock().await;
|
||||
match sessions.get(&id) {
|
||||
None => return Err(SessionError::NotFound(id)),
|
||||
@@ -405,26 +437,75 @@ impl SessionManager {
|
||||
.clone()
|
||||
.zip(record.worktree_path.clone()),
|
||||
record.session.status == SessionStatus::Running,
|
||||
record.worktree_branch.clone(),
|
||||
),
|
||||
}
|
||||
};
|
||||
// The guard runs before anything is torn down: refusing must leave the
|
||||
// session running, exactly as the operator left it.
|
||||
if let Some((_, path)) = worktree {
|
||||
let probe = tmux_blocking(move || crate::worktree_probe::in_the_way(&path))
|
||||
.await
|
||||
.map_err(|e| SessionError::Worktree(crate::worktree::WorktreeError::from(e)))?;
|
||||
if !probe.is_clear() {
|
||||
return Err(SessionError::KillGuarded(probe));
|
||||
// The probe runs before anything is torn down: both refusing (#79)
|
||||
// and recording the retention (#81) must see the tree as it stands,
|
||||
// and a refused kill leaves the session running as the operator left
|
||||
// it.
|
||||
let probe = match &worktree {
|
||||
Some((_, path)) => {
|
||||
let path = path.clone();
|
||||
Some(
|
||||
tmux_blocking(move || crate::worktree_probe::in_the_way(&path))
|
||||
.await
|
||||
.map_err(|e| {
|
||||
SessionError::Worktree(crate::worktree::WorktreeError::from(e))
|
||||
})?,
|
||||
)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let guarded = probe.as_ref().is_some_and(|p| !p.is_clear());
|
||||
if guarded && !force {
|
||||
return Err(SessionError::KillGuarded(probe.expect("guarded ⇒ probed")));
|
||||
}
|
||||
|
||||
// Record the retention BEFORE tearing down: a failed store write then
|
||||
// leaves the session running and every artifact untouched, instead of
|
||||
// ending a session whose work outlives it unrecorded.
|
||||
let mut retained = None;
|
||||
if guarded {
|
||||
let store =
|
||||
self.inner.retained.clone().ok_or_else(|| {
|
||||
SessionError::RetainFailed("no retained store is wired".into())
|
||||
})?;
|
||||
let (base_repo, path) = worktree.as_ref().expect("guarded ⇒ worktree");
|
||||
let branch = known_branch
|
||||
.or_else(|| crate::worktree_probe::current_branch(path))
|
||||
.unwrap_or_default();
|
||||
let entry = {
|
||||
let store = store.clone();
|
||||
let base_repo = base_repo.clone();
|
||||
let path = path.clone();
|
||||
tmux_blocking(move || {
|
||||
store.retain(&path, &base_repo, &branch, RetainedReason::ForceKilled)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| SessionError::RetainFailed(e.to_string()))?
|
||||
};
|
||||
retained = Some((entry, probe.expect("guarded ⇒ probed")));
|
||||
}
|
||||
|
||||
let removed = {
|
||||
let mut sessions = self.inner.sessions.lock().await;
|
||||
sessions.remove(&id)
|
||||
};
|
||||
let record = removed.ok_or(SessionError::NotFound(id))?;
|
||||
cleanup_record(&self.inner, id, record, alive).await;
|
||||
Ok(())
|
||||
cleanup_record(&self.inner, id, record, alive, retained.is_some()).await;
|
||||
Ok(KillOutcome {
|
||||
retained: retained.map(|(entry, in_the_way)| RetainedWorktree {
|
||||
id: entry.id,
|
||||
path: entry.path,
|
||||
base_repo: entry.base_repo,
|
||||
branch: entry.branch,
|
||||
reason: entry.reason,
|
||||
retained_at: entry.retained_at,
|
||||
in_the_way,
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
/// Spawn a background task that polls tmux every `interval` and reaps any
|
||||
@@ -511,6 +592,9 @@ impl SessionManager {
|
||||
// directory blocks that branch forever (#54 review).
|
||||
worktree_path: session.worktree.as_ref().map(|w| w.path.clone()),
|
||||
worktree_base_repo: session.worktree.as_ref().map(|w| w.base_repo.clone()),
|
||||
// The sidecar carries no branch; a forced kill of a
|
||||
// recovered session probes git for it at retain time.
|
||||
worktree_branch: None,
|
||||
bridge,
|
||||
},
|
||||
);
|
||||
@@ -750,7 +834,17 @@ async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
|
||||
/// gone from the authoritative in-memory map, so a stray FIFO or sidecar can't
|
||||
/// resurrect it. `kill_tmux` is `true` for an explicit kill and `false` for the
|
||||
/// liveness reaper (tmux already lost the session).
|
||||
async fn cleanup_record(inner: &Arc<Inner>, id: Uuid, record: SessionRecord, kill_tmux: bool) {
|
||||
///
|
||||
/// `retain_worktree` is `true` for a forced kill (#81) that retained the
|
||||
/// worktree instead of removing it: the store entry is already written, so
|
||||
/// only the removal is skipped.
|
||||
async fn cleanup_record(
|
||||
inner: &Arc<Inner>,
|
||||
id: Uuid,
|
||||
record: SessionRecord,
|
||||
kill_tmux: bool,
|
||||
retain_worktree: bool,
|
||||
) {
|
||||
if kill_tmux {
|
||||
let tmux = inner.tmux.clone();
|
||||
let _ = tmux_blocking(move || tmux.kill_session(id)).await;
|
||||
@@ -759,11 +853,18 @@ async fn cleanup_record(inner: &Arc<Inner>, id: Uuid, record: SessionRecord, kil
|
||||
if let Err(e) = inner.sidecar.delete(id) {
|
||||
tracing::warn!(error = ?e, %id, "cleanup: failed to delete sidecar");
|
||||
}
|
||||
// The kill already passed the unsaved-work guard (#79), so this removal
|
||||
// is unconditional; the manager's own nested-worktree refusal is all that
|
||||
// can still leave a tree on disk, and it says where.
|
||||
if let (Some(base), Some(path)) = (&record.worktree_base_repo, &record.worktree_path) {
|
||||
if let Err(e) = inner.worktree_mgr.remove(base, path) {
|
||||
if retain_worktree {
|
||||
tracing::info!(
|
||||
%id,
|
||||
path = %path.display(),
|
||||
"forced kill: worktree retained in the store"
|
||||
);
|
||||
} else if let Err(e) = inner.worktree_mgr.remove(base, path) {
|
||||
// The kill already passed the unsaved-work guard (#79), so this
|
||||
// removal is unconditional; the manager's own nested-worktree
|
||||
// refusal is all that can still leave a tree on disk, and it
|
||||
// says where.
|
||||
tracing::warn!(
|
||||
%id,
|
||||
path = %path.display(),
|
||||
|
||||
@@ -90,6 +90,14 @@ pub fn reclaim(base_repo: &Path, path: &Path) -> Result<(), ProbeError> {
|
||||
.map(|_| ())
|
||||
}
|
||||
|
||||
/// Branch checked out at `path`. Sessions adopted from a sidecar carry no
|
||||
/// branch on record, so a forced kill (#81) asks the tree itself when it
|
||||
/// needs one for the retained store. `None` when git cannot answer.
|
||||
pub fn current_branch(path: &Path) -> Option<String> {
|
||||
let out = run_git(path, ["rev-parse", "--abbrev-ref", "HEAD"]).ok()?;
|
||||
Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
|
||||
}
|
||||
|
||||
fn run_git<I, S>(dir: &Path, args: I) -> Result<std::process::Output, ProbeError>
|
||||
where
|
||||
I: IntoIterator<Item = S>,
|
||||
|
||||
Reference in New Issue
Block a user