Compare commits
6
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2083911baa | ||
|
|
b5450651d1 | ||
|
|
dde8dd8cfc | ||
|
|
2fc19a886e | ||
|
|
0b95d11aa6 | ||
|
|
a85084d0d9 |
@@ -441,21 +441,8 @@ impl SessionManager {
|
|||||||
),
|
),
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
// 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 {
|
let probe = match &worktree {
|
||||||
Some((_, path)) => {
|
Some(wt) => Some(probe_worktree(wt).await?),
|
||||||
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,
|
None => None,
|
||||||
};
|
};
|
||||||
let guarded = probe.as_ref().is_some_and(|p| !p.is_clear());
|
let guarded = probe.as_ref().is_some_and(|p| !p.is_clear());
|
||||||
@@ -463,29 +450,15 @@ impl SessionManager {
|
|||||||
return Err(SessionError::KillGuarded(probe.expect("guarded ⇒ probed")));
|
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;
|
let mut retained = None;
|
||||||
if guarded {
|
if guarded {
|
||||||
let store =
|
let entry = record_retention(
|
||||||
self.inner.retained.clone().ok_or_else(|| {
|
&self.inner,
|
||||||
SessionError::RetainFailed("no retained store is wired".into())
|
worktree.as_ref().expect("guarded ⇒ worktree"),
|
||||||
})?;
|
known_branch,
|
||||||
let (base_repo, path) = worktree.as_ref().expect("guarded ⇒ worktree");
|
RetainedReason::ForceKilled,
|
||||||
let branch = known_branch
|
)
|
||||||
.or_else(|| crate::worktree_probe::current_branch(path))
|
.await?;
|
||||||
.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")));
|
retained = Some((entry, probe.expect("guarded ⇒ probed")));
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -671,6 +644,49 @@ where
|
|||||||
.expect("tmux blocking task panicked")
|
.expect("tmux blocking task panicked")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// What would be lost if this session's worktree were removed right now.
|
||||||
|
///
|
||||||
|
/// The single [`crate::worktree_probe::in_the_way`] call site behind both
|
||||||
|
/// endings of a session — the kill guard (#79) and the natural-exit
|
||||||
|
/// classifier (#82) — so neither can grow its own answer. Runs on the
|
||||||
|
/// blocking pool; callers invoke it before anything is torn down, because
|
||||||
|
/// refusing (#79), recording a retention (#81) and classifying an exit (#82)
|
||||||
|
/// must all see the tree as it stands.
|
||||||
|
async fn probe_worktree(
|
||||||
|
(_, path): &(PathBuf, PathBuf),
|
||||||
|
) -> Result<maestro_protocol::InTheWay, SessionError> {
|
||||||
|
let path = path.clone();
|
||||||
|
tmux_blocking(move || crate::worktree_probe::in_the_way(&path))
|
||||||
|
.await
|
||||||
|
.map_err(|e| SessionError::Worktree(crate::worktree::WorktreeError::from(e)))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Record a guarded worktree into the retained store with `reason`, BEFORE
|
||||||
|
/// the caller tears anything down: a failed write then leaves every artifact
|
||||||
|
/// untouched instead of destroying work nothing records anymore. Shared by
|
||||||
|
/// the forced kill (`ForceKilled`, #81) and the natural exit
|
||||||
|
/// (`ExitedWithUnsavedWork`, #82) so the two paths cannot drift apart.
|
||||||
|
async fn record_retention(
|
||||||
|
inner: &Arc<Inner>,
|
||||||
|
(base_repo, path): &(PathBuf, PathBuf),
|
||||||
|
known_branch: Option<String>,
|
||||||
|
reason: RetainedReason,
|
||||||
|
) -> Result<crate::retained_store::RetainedWorktreeRecord, SessionError> {
|
||||||
|
let store = inner
|
||||||
|
.retained
|
||||||
|
.clone()
|
||||||
|
.ok_or_else(|| SessionError::RetainFailed("no retained store is wired".into()))?;
|
||||||
|
// Sessions adopted from a sidecar carry no branch; ask the tree itself.
|
||||||
|
let branch = known_branch
|
||||||
|
.or_else(|| crate::worktree_probe::current_branch(path))
|
||||||
|
.unwrap_or_default();
|
||||||
|
let base_repo = base_repo.clone();
|
||||||
|
let path = path.clone();
|
||||||
|
tmux_blocking(move || store.retain(&path, &base_repo, &branch, reason))
|
||||||
|
.await
|
||||||
|
.map_err(|e| SessionError::RetainFailed(e.to_string()))
|
||||||
|
}
|
||||||
|
|
||||||
/// One pass of the liveness watcher: diff the in-memory session set against
|
/// One pass of the liveness watcher: diff the in-memory session set against
|
||||||
/// the tmux-reported one, and reap anything we still track but tmux has lost.
|
/// the tmux-reported one, and reap anything we still track but tmux has lost.
|
||||||
async fn run_liveness_pass(inner: &Arc<Inner>) {
|
async fn run_liveness_pass(inner: &Arc<Inner>) {
|
||||||
@@ -794,17 +810,23 @@ async fn run_activity_pass(inner: &Arc<Inner>) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// Mark a session whose tmux session has disappeared as [`SessionStatus::Dead`]
|
/// Mark a session whose tmux session has disappeared as [`SessionStatus::Dead`]
|
||||||
/// and announce it, keeping everything else intact.
|
/// and settle its worktree per the natural-exit rule (#82).
|
||||||
///
|
///
|
||||||
/// The record, its [`PtyBridge`] and its sidecar all survive, so a client can
|
/// The record, its [`PtyBridge`] and its sidecar all survive, so a client can
|
||||||
/// still attach and read the replay buffer — the last thing a crashed agent
|
/// still attach and read the replay buffer — the last thing a crashed agent
|
||||||
/// printed. Artifacts are only released when the operator dismisses the session
|
/// printed. The worktree, though, is settled right away: a pristine tree is
|
||||||
/// via [`SessionManager::kill`].
|
/// removed, anything else is retained into the store with reason
|
||||||
|
/// `exited-with-unsaved-work` (#82) — nobody is waiting for an answer here,
|
||||||
|
/// so there is nothing to refuse. Once settled, the session drops its
|
||||||
|
/// worktree reference so a later dismissal neither re-probes nor retains
|
||||||
|
/// twice. When settling is impossible (probe or store failure) nothing is
|
||||||
|
/// destroyed: the tree stays attached to the dead record for a later forced
|
||||||
|
/// dismissal (#81).
|
||||||
///
|
///
|
||||||
/// Dead sessions do not survive a daemon restart: [`SessionManager::recover`]
|
/// Dead sessions do not survive a daemon restart: [`SessionManager::recover`]
|
||||||
/// adopts only what tmux still holds.
|
/// adopts only what tmux still holds.
|
||||||
async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
|
async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
|
||||||
let updated = {
|
let flipped = {
|
||||||
let mut sessions = inner.sessions.lock().await;
|
let mut sessions = inner.sessions.lock().await;
|
||||||
match sessions.get_mut(&id) {
|
match sessions.get_mut(&id) {
|
||||||
Some(record) if record.session.status == SessionStatus::Running => {
|
Some(record) if record.session.status == SessionStatus::Running => {
|
||||||
@@ -812,19 +834,111 @@ async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
|
|||||||
// Release anyone attached; the scrollback survives for a later
|
// Release anyone attached; the scrollback survives for a later
|
||||||
// attach.
|
// attach.
|
||||||
record.bridge.seal();
|
record.bridge.seal();
|
||||||
Some(record.session.clone())
|
let session = record.session.clone();
|
||||||
|
let worktree = record
|
||||||
|
.worktree_base_repo
|
||||||
|
.clone()
|
||||||
|
.zip(record.worktree_path.clone());
|
||||||
|
let branch = record.worktree_branch.clone();
|
||||||
|
Some((session, worktree, branch))
|
||||||
}
|
}
|
||||||
_ => None,
|
_ => None,
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
let Some(session) = updated else {
|
let Some((mut session, worktree, branch)) = flipped else {
|
||||||
return;
|
return;
|
||||||
};
|
};
|
||||||
tracing::info!(%id, "session vanished from tmux — marking dead");
|
tracing::info!(%id, "session vanished from tmux — marking dead");
|
||||||
|
|
||||||
|
if let Some(wt) = &worktree {
|
||||||
|
if settle_worktree_on_exit(inner, id, wt, branch).await {
|
||||||
|
session.worktree = None;
|
||||||
|
let mut sessions = inner.sessions.lock().await;
|
||||||
|
if let Some(record) = sessions.get_mut(&id) {
|
||||||
|
record.session.worktree = None;
|
||||||
|
record.worktree_path = None;
|
||||||
|
record.worktree_base_repo = None;
|
||||||
|
record.worktree_branch = None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
let _ = inner.sidecar.write(&session);
|
let _ = inner.sidecar.write(&session);
|
||||||
let _ = inner.events.send(CatalogEvent::SessionUpdated { session });
|
let _ = inner.events.send(CatalogEvent::SessionUpdated { session });
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Apply the exit rule (#82) to a vanished session's worktree: probe what
|
||||||
|
/// would be lost through the kill's own predicate, then remove a pristine
|
||||||
|
/// tree or retain anything else under `exited-with-unsaved-work` — recorded
|
||||||
|
/// before anything is torn down, exactly as the forced kill does (#81). A
|
||||||
|
/// removal that fails falls back to retaining, since whatever blocked it is
|
||||||
|
/// by definition something worth keeping.
|
||||||
|
///
|
||||||
|
/// Returns whether the worktree was fully accounted for. When it wasn't,
|
||||||
|
/// nothing was destroyed and the caller keeps the reference on the record.
|
||||||
|
async fn settle_worktree_on_exit(
|
||||||
|
inner: &Arc<Inner>,
|
||||||
|
id: Uuid,
|
||||||
|
(base_repo, path): &(PathBuf, PathBuf),
|
||||||
|
known_branch: Option<String>,
|
||||||
|
) -> bool {
|
||||||
|
let probe = match probe_worktree(&(base_repo.clone(), path.clone())).await {
|
||||||
|
Ok(probe) => probe,
|
||||||
|
Err(e) => {
|
||||||
|
tracing::error!(
|
||||||
|
%id,
|
||||||
|
path = %path.display(),
|
||||||
|
error = ?e,
|
||||||
|
"natural exit: could not probe the worktree; leaving it untouched"
|
||||||
|
);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if probe.is_clear() {
|
||||||
|
match inner.worktree_mgr.remove(base_repo, path) {
|
||||||
|
Ok(()) => {
|
||||||
|
tracing::info!(%id, path = %path.display(), "natural exit: pristine worktree removed");
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
tracing::warn!(
|
||||||
|
%id,
|
||||||
|
path = %path.display(),
|
||||||
|
error = ?e,
|
||||||
|
"natural exit: removal failed; falling back to retention"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
match record_retention(
|
||||||
|
inner,
|
||||||
|
&(base_repo.clone(), path.clone()),
|
||||||
|
known_branch,
|
||||||
|
RetainedReason::ExitedWithUnsavedWork,
|
||||||
|
)
|
||||||
|
.await
|
||||||
|
{
|
||||||
|
Ok(entry) => {
|
||||||
|
tracing::info!(
|
||||||
|
%id,
|
||||||
|
path = %path.display(),
|
||||||
|
entry = %entry.id,
|
||||||
|
"natural exit: worktree retained with unsaved work"
|
||||||
|
);
|
||||||
|
true
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
tracing::error!(
|
||||||
|
%id,
|
||||||
|
path = %path.display(),
|
||||||
|
error = ?e,
|
||||||
|
"natural exit: could not record the retained worktree; leaving it untouched"
|
||||||
|
);
|
||||||
|
false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Tear down a session's artifacts after it has already been removed from the
|
/// Tear down a session's artifacts after it has already been removed from the
|
||||||
/// live map. Shared by [`SessionManager::kill`] and [`reap_dead_session`],
|
/// live map. Shared by [`SessionManager::kill`] and [`reap_dead_session`],
|
||||||
/// which previously hand-rolled the same five-step choreography and only
|
/// which previously hand-rolled the same five-step choreography and only
|
||||||
|
|||||||
@@ -8,7 +8,9 @@ use std::process::Command;
|
|||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
|
|
||||||
use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
|
use common::{
|
||||||
|
init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture, TmuxFixture,
|
||||||
|
};
|
||||||
use maestro_daemon::SessionError;
|
use maestro_daemon::SessionError;
|
||||||
use maestro_protocol::CreateSessionRequest;
|
use maestro_protocol::CreateSessionRequest;
|
||||||
use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
|
use maestro_protocol::{CatalogEvent, SessionStatus, WorktreeSpec};
|
||||||
@@ -668,6 +670,191 @@ async fn killing_an_ignored_only_worktree_succeeds() {
|
|||||||
assert!(!fx.manager.has(s.id).await);
|
assert!(!fx.manager.has(s.id).await);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Natural exit (#82): a session that ends on its own never reaches the kill
|
||||||
|
/// path, so the watcher applies the kill's rule itself. A worktree holding
|
||||||
|
/// unsaved work is RETAINED into the store with reason
|
||||||
|
/// `exited-with-unsaved-work`; the session stays in the catalog marked dead
|
||||||
|
/// until dismissed — and dismissing it afterwards neither refuses nor
|
||||||
|
/// retains a second time.
|
||||||
|
#[tokio::test]
|
||||||
|
async fn natural_exit_of_a_guarded_worktree_retains_it_in_the_store() {
|
||||||
|
let fx = DaemonFixture::new();
|
||||||
|
let repo = TempDir::new().unwrap();
|
||||||
|
init_repo(repo.path());
|
||||||
|
let wt_path = repo.path().join("worktrees").join("feat").join("exited");
|
||||||
|
|
||||||
|
let s = fx
|
||||||
|
.manager
|
||||||
|
.create(CreateSessionRequest {
|
||||||
|
cwd: repo.path().to_path_buf(),
|
||||||
|
command: "sleep 30".into(),
|
||||||
|
env: HashMap::new(),
|
||||||
|
metadata: HashMap::new(),
|
||||||
|
worktree: Some(WorktreeSpec {
|
||||||
|
base_repo: repo.path().to_path_buf(),
|
||||||
|
branch: "feat/exited".into(),
|
||||||
|
cleanup_on_kill: true,
|
||||||
|
create_branch: true,
|
||||||
|
}),
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.expect("create");
|
||||||
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
||||||
|
|
||||||
|
// The command finishes / the operator types exit: tmux loses the session.
|
||||||
|
fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
||||||
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
||||||
|
wait_for_async(Duration::from_secs(3), || async {
|
||||||
|
fx.manager.status(s.id).await == Some(SessionStatus::Dead)
|
||||||
|
})
|
||||||
|
.await;
|
||||||
|
|
||||||
|
// The tree would have blocked a kill, so the exit kept it...
|
||||||
|
assert!(
|
||||||
|
wt_path.exists(),
|
||||||
|
"a dirty worktree must be retained on natural exit"
|
||||||
|
);
|
||||||
|
// ...in the store, under the exit reason.
|
||||||
|
let all = fx.retained_store().load_all().expect("load_all");
|
||||||
|
assert_eq!(all.len(), 1);
|
||||||
|
assert_eq!(all[0].path, wt_path);
|
||||||
|
assert_eq!(all[0].branch, "feat/exited");
|
||||||
|
assert_eq!(
|
||||||
|
all[0].reason,
|
||||||
|
maestro_protocol::RetainedReason::ExitedWithUnsavedWork
|
||||||
|
);
|
||||||
|
|
||||||
|
// The session itself stays until dismissed; its worktree reference is
|
||||||
|
// settled, so dismissal is neither refused nor retained twice.
|
||||||
|
// (`Dead` is observable a moment before the settle step finishes.)
|
||||||
|
wait_for_async(Duration::from_secs(3), || async {
|
||||||
|
fx.manager.snapshot().await[0].worktree.is_none()
|
||||||
|
})
|
||||||
|
.await;
|
||||||
|
let snap = fx.manager.snapshot().await;
|
||||||
|
assert_eq!(snap.len(), 1);
|
||||||
|
assert_eq!(snap[0].worktree, None);
|
||||||
|
|
||||||
|
fx.manager.kill(s.id, false).await.expect("dismiss");
|
||||||
|
assert!(!fx.manager.has(s.id).await);
|
||||||
|
assert!(
|
||||||
|
wt_path.exists(),
|
||||||
|
"dismissal must not remove what was retained"
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
fx.retained_store().load_all().unwrap().len(),
|
||||||
|
1,
|
||||||
|
"dismissal must not record a second entry for the same tree"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Natural exit (#82), pristine side of the same rule: nothing in the tree,
|
||||||
|
/// nothing to keep — the worktree is removed and no store entry appears.
|
||||||
|
#[tokio::test]
|
||||||
|
async fn natural_exit_of_a_pristine_worktree_removes_it() {
|
||||||
|
let fx = DaemonFixture::new();
|
||||||
|
let repo = TempDir::new().unwrap();
|
||||||
|
init_repo(repo.path());
|
||||||
|
let wt_path = repo.path().join("worktrees").join("feat").join("clean");
|
||||||
|
|
||||||
|
let s = fx
|
||||||
|
.manager
|
||||||
|
.create(CreateSessionRequest {
|
||||||
|
cwd: repo.path().to_path_buf(),
|
||||||
|
command: "sleep 30".into(),
|
||||||
|
env: HashMap::new(),
|
||||||
|
metadata: HashMap::new(),
|
||||||
|
worktree: Some(WorktreeSpec {
|
||||||
|
base_repo: repo.path().to_path_buf(),
|
||||||
|
branch: "feat/clean".into(),
|
||||||
|
cleanup_on_kill: true,
|
||||||
|
create_branch: true,
|
||||||
|
}),
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.expect("create");
|
||||||
|
|
||||||
|
// Push everything so the branch has no unpushed commits: fully pristine.
|
||||||
|
let origin = TempDir::new().unwrap();
|
||||||
|
init_bare_repo(origin.path());
|
||||||
|
push_all_to_origin(repo.path(), origin.path());
|
||||||
|
|
||||||
|
fx.tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
||||||
|
fx.manager.start_liveness_watcher(Duration::from_millis(50));
|
||||||
|
wait_for_async(Duration::from_secs(3), || async {
|
||||||
|
fx.manager.status(s.id).await == Some(SessionStatus::Dead)
|
||||||
|
})
|
||||||
|
.await;
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
!wt_path.exists(),
|
||||||
|
"a pristine worktree leaves nothing behind"
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
fx.retained_store().load_all().unwrap().is_empty(),
|
||||||
|
"nothing was retained"
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
fx.manager.has(s.id).await,
|
||||||
|
"the session stays until dismissed"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// When nothing can be recorded — here: no retained store wired — the exit
|
||||||
|
/// destroys nothing. The tree stays on disk AND stays attached to the dead
|
||||||
|
/// record, where dismissing it later still goes through #81's forced-kill
|
||||||
|
/// retention. Losing the store must not lose the work.
|
||||||
|
#[tokio::test]
|
||||||
|
async fn natural_exit_without_a_retained_store_destroys_nothing() {
|
||||||
|
let tmux = TmuxFixture::new();
|
||||||
|
let state_dir = TempDir::new().unwrap();
|
||||||
|
let manager = maestro_daemon::SessionManager::new(
|
||||||
|
Arc::new(tmux.tmux.clone()),
|
||||||
|
maestro_daemon::sidecar::SidecarStore::new(state_dir.path().join("sessions")),
|
||||||
|
maestro_daemon::worktree::WorktreeManager::new(None),
|
||||||
|
state_dir.path().join("fifos"),
|
||||||
|
);
|
||||||
|
// Deliberately NO with_retained_store.
|
||||||
|
|
||||||
|
let repo = TempDir::new().unwrap();
|
||||||
|
init_repo(repo.path());
|
||||||
|
let wt_path = repo.path().join("worktrees").join("feat").join("nostore");
|
||||||
|
|
||||||
|
let s = manager
|
||||||
|
.create(CreateSessionRequest {
|
||||||
|
cwd: repo.path().to_path_buf(),
|
||||||
|
command: "sleep 30".into(),
|
||||||
|
env: HashMap::new(),
|
||||||
|
metadata: HashMap::new(),
|
||||||
|
worktree: Some(WorktreeSpec {
|
||||||
|
base_repo: repo.path().to_path_buf(),
|
||||||
|
branch: "feat/nostore".into(),
|
||||||
|
cleanup_on_kill: true,
|
||||||
|
create_branch: true,
|
||||||
|
}),
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.expect("create");
|
||||||
|
std::fs::write(wt_path.join("README"), b"unsaved edits\n").unwrap();
|
||||||
|
|
||||||
|
tmux.tmux.kill_session(s.id).expect("kill tmux directly");
|
||||||
|
manager.start_liveness_watcher(Duration::from_millis(50));
|
||||||
|
wait_for_async(Duration::from_secs(3), || async {
|
||||||
|
manager.status(s.id).await == Some(SessionStatus::Dead)
|
||||||
|
})
|
||||||
|
.await;
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
wt_path.exists(),
|
||||||
|
"nothing may be destroyed when it cannot be recorded"
|
||||||
|
);
|
||||||
|
let snap = manager.snapshot().await;
|
||||||
|
assert!(
|
||||||
|
snap[0].worktree.is_some(),
|
||||||
|
"the tree must stay attached to the record so a later forced kill can retain it"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
fn run_git_in(dir: &std::path::Path, args: &[&str]) {
|
fn run_git_in(dir: &std::path::Path, args: &[&str]) {
|
||||||
let out = Command::new("git")
|
let out = Command::new("git")
|
||||||
.arg("-C")
|
.arg("-C")
|
||||||
|
|||||||
@@ -12,7 +12,8 @@ use std::time::Duration;
|
|||||||
|
|
||||||
use futures_util::{SinkExt, StreamExt};
|
use futures_util::{SinkExt, StreamExt};
|
||||||
use maestro_protocol::{
|
use maestro_protocol::{
|
||||||
BranchInfo, CatalogEvent, CreateSessionRequest, DaemonClient, Project, Session,
|
BranchInfo, CatalogEvent, CreateSessionRequest, DaemonClient, KillOutcome, Project,
|
||||||
|
RetainedWorktree, Session,
|
||||||
};
|
};
|
||||||
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
|
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
|
||||||
use tokio_tungstenite::tungstenite::Message as WsMessage;
|
use tokio_tungstenite::tungstenite::Message as WsMessage;
|
||||||
@@ -64,6 +65,20 @@ impl TestClient {
|
|||||||
Ok(self.daemon.kill_session(id, false).await.map(|_| ())?)
|
Ok(self.daemon.kill_session(id, false).await.map(|_| ())?)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Kill with `force=true`: overrides a kill refusal and retains the
|
||||||
|
/// guarded worktree (#81). Answers with what was kept.
|
||||||
|
pub async fn kill_session_forced(&self, id: Uuid) -> Result<KillOutcome, ClientError> {
|
||||||
|
Ok(self.daemon.kill_session(id, true).await?)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn list_worktrees(&self) -> Result<Vec<RetainedWorktree>, ClientError> {
|
||||||
|
Ok(self.daemon.list_worktrees().await?)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn reclaim_worktree(&self, id: Uuid) -> Result<(), ClientError> {
|
||||||
|
Ok(self.daemon.reclaim_worktree(id).await?)
|
||||||
|
}
|
||||||
|
|
||||||
pub async fn list_projects(&self) -> Result<Vec<Project>, ClientError> {
|
pub async fn list_projects(&self) -> Result<Vec<Project>, ClientError> {
|
||||||
Ok(self.daemon.list_projects().await?)
|
Ok(self.daemon.list_projects().await?)
|
||||||
}
|
}
|
||||||
|
|||||||
+523
-33
@@ -35,6 +35,18 @@ fn create_req(cwd: &std::path::Path, command: &str) -> CreateSessionRequest {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A worktree spec built through its wire shape. The daemon and clients ship
|
||||||
|
/// together (#87 dropped `cleanup_on_kill` from the struct), so the JSON
|
||||||
|
/// object carries only the fields the lifecycle actually honours.
|
||||||
|
fn worktree_spec(base_repo: &std::path::Path, branch: &str, create_branch: bool) -> WorktreeSpec {
|
||||||
|
serde_json::from_value(serde_json::json!({
|
||||||
|
"base_repo": base_repo,
|
||||||
|
"branch": branch,
|
||||||
|
"create_branch": create_branch,
|
||||||
|
}))
|
||||||
|
.expect("worktree spec")
|
||||||
|
}
|
||||||
|
|
||||||
/// Spawn request carrying a worktree spec against `base`.
|
/// Spawn request carrying a worktree spec against `base`.
|
||||||
fn worktree_req(base: &std::path::Path, branch: &str, create_branch: bool) -> CreateSessionRequest {
|
fn worktree_req(base: &std::path::Path, branch: &str, create_branch: bool) -> CreateSessionRequest {
|
||||||
CreateSessionRequest {
|
CreateSessionRequest {
|
||||||
@@ -42,12 +54,7 @@ fn worktree_req(base: &std::path::Path, branch: &str, create_branch: bool) -> Cr
|
|||||||
command: "sleep 30".into(),
|
command: "sleep 30".into(),
|
||||||
env: HashMap::new(),
|
env: HashMap::new(),
|
||||||
metadata: HashMap::new(),
|
metadata: HashMap::new(),
|
||||||
worktree: Some(WorktreeSpec {
|
worktree: Some(worktree_spec(base, branch, create_branch)),
|
||||||
base_repo: base.to_path_buf(),
|
|
||||||
branch: branch.into(),
|
|
||||||
cleanup_on_kill: true,
|
|
||||||
create_branch,
|
|
||||||
}),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -141,12 +148,7 @@ async fn kill_removes_clean_worktree() {
|
|||||||
command: "sleep 30".into(),
|
command: "sleep 30".into(),
|
||||||
env: HashMap::new(),
|
env: HashMap::new(),
|
||||||
metadata: HashMap::new(),
|
metadata: HashMap::new(),
|
||||||
worktree: Some(WorktreeSpec {
|
worktree: Some(worktree_spec(base.path(), "feature/e2e", true)),
|
||||||
base_repo: base.path().to_path_buf(),
|
|
||||||
branch: "feature/e2e".into(),
|
|
||||||
cleanup_on_kill: true,
|
|
||||||
create_branch: true,
|
|
||||||
}),
|
|
||||||
};
|
};
|
||||||
|
|
||||||
let s = client.spawn_session(&req).await.expect("spawn worktree");
|
let s = client.spawn_session(&req).await.expect("spawn worktree");
|
||||||
@@ -160,7 +162,7 @@ async fn kill_removes_clean_worktree() {
|
|||||||
"expected a worktree for feature/e2e under <repo>/worktrees, got: {worktrees:?}"
|
"expected a worktree for feature/e2e under <repo>/worktrees, got: {worktrees:?}"
|
||||||
);
|
);
|
||||||
|
|
||||||
push_to_throwaway_origin(base.path());
|
let _origin = throwaway_origin(base.path());
|
||||||
client.kill_session(s.id).await.expect("kill");
|
client.kill_session(s.id).await.expect("kill");
|
||||||
|
|
||||||
// Give the daemon a moment to remove the worktree, then verify.
|
// Give the daemon a moment to remove the worktree, then verify.
|
||||||
@@ -199,12 +201,7 @@ async fn kill_refuses_worktree_with_uncommitted_changes() {
|
|||||||
command: "sleep 30".into(),
|
command: "sleep 30".into(),
|
||||||
env: HashMap::new(),
|
env: HashMap::new(),
|
||||||
metadata: HashMap::new(),
|
metadata: HashMap::new(),
|
||||||
worktree: Some(WorktreeSpec {
|
worktree: Some(worktree_spec(base.path(), "feature/unsaved", true)),
|
||||||
base_repo: base.path().to_path_buf(),
|
|
||||||
branch: "feature/unsaved".into(),
|
|
||||||
cleanup_on_kill: true,
|
|
||||||
create_branch: true,
|
|
||||||
}),
|
|
||||||
};
|
};
|
||||||
|
|
||||||
let s = client.spawn_session(&req).await.expect("spawn worktree");
|
let s = client.spawn_session(&req).await.expect("spawn worktree");
|
||||||
@@ -262,12 +259,7 @@ async fn spawn_on_existing_branch_checks_it_out() {
|
|||||||
command: "sleep 30".into(),
|
command: "sleep 30".into(),
|
||||||
env: HashMap::new(),
|
env: HashMap::new(),
|
||||||
metadata: HashMap::new(),
|
metadata: HashMap::new(),
|
||||||
worktree: Some(WorktreeSpec {
|
worktree: Some(worktree_spec(base.path(), "feature/existing", false)),
|
||||||
base_repo: base.path().to_path_buf(),
|
|
||||||
branch: "feature/existing".into(),
|
|
||||||
cleanup_on_kill: true,
|
|
||||||
create_branch: false,
|
|
||||||
}),
|
|
||||||
};
|
};
|
||||||
|
|
||||||
let s = client
|
let s = client
|
||||||
@@ -280,7 +272,7 @@ async fn spawn_on_existing_branch_checks_it_out() {
|
|||||||
"expected a worktree checked out at feature/existing, got: {worktrees:?}"
|
"expected a worktree checked out at feature/existing, got: {worktrees:?}"
|
||||||
);
|
);
|
||||||
|
|
||||||
push_to_throwaway_origin(base.path());
|
let _origin = throwaway_origin(base.path());
|
||||||
client.kill_session(s.id).await.expect("kill");
|
client.kill_session(s.id).await.expect("kill");
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -328,7 +320,7 @@ async fn spawn_new_branch_creates_worktree_and_runs_in_it() {
|
|||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
|
||||||
push_to_throwaway_origin(base.path());
|
let _origin = throwaway_origin(base.path());
|
||||||
client.kill_session(s.id).await.expect("kill");
|
client.kill_session(s.id).await.expect("kill");
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -376,7 +368,7 @@ async fn second_spawn_on_same_branch_is_rejected() {
|
|||||||
"original worktree must be untouched"
|
"original worktree must be untouched"
|
||||||
);
|
);
|
||||||
|
|
||||||
push_to_throwaway_origin(base.path());
|
let _origin = throwaway_origin(base.path());
|
||||||
client.kill_session(first.id).await.expect("kill");
|
client.kill_session(first.id).await.expect("kill");
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -419,10 +411,481 @@ async fn spawn_from_linked_worktree_places_in_main_checkout() {
|
|||||||
"worktrees must never nest inside another worktree"
|
"worktrees must never nest inside another worktree"
|
||||||
);
|
);
|
||||||
|
|
||||||
push_to_throwaway_origin(base.path());
|
let _origin = throwaway_origin(base.path());
|
||||||
client.kill_session(s.id).await.expect("kill");
|
client.kill_session(s.id).await.expect("kill");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
// Worktree lifecycle: collisions, retention, reclaim (#88)
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
/// #77/#88: the target path `<repo>/worktrees/<branch>` is occupied by a real
|
||||||
|
/// registered worktree the operator made by hand. The daemon sidesteps to the
|
||||||
|
/// suffixed directory and never touches the occupant — and both trees keep
|
||||||
|
/// working: two registered worktrees, two sessions, each running in its own.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn occupied_path_gets_suffixed_directory_and_both_worktrees_work() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
|
||||||
|
// An operator-made worktree sits exactly where `feature/collide` would go.
|
||||||
|
// Its branch is a different one, so the requested branch stays creatable.
|
||||||
|
let squatter = base
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("collide");
|
||||||
|
run_git(
|
||||||
|
&[
|
||||||
|
"worktree",
|
||||||
|
"add",
|
||||||
|
"-q",
|
||||||
|
"-b",
|
||||||
|
"operator/manual",
|
||||||
|
&squatter.to_string_lossy(),
|
||||||
|
],
|
||||||
|
base.path(),
|
||||||
|
);
|
||||||
|
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/collide", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn onto occupied path");
|
||||||
|
|
||||||
|
let suffixed = base
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("collide-2");
|
||||||
|
assert_eq!(
|
||||||
|
s.cwd, suffixed,
|
||||||
|
"the daemon must take the suffixed directory, not the occupied one"
|
||||||
|
);
|
||||||
|
assert!(suffixed.is_dir(), "suffixed worktree must exist on disk");
|
||||||
|
|
||||||
|
// Both trees are registered, distinct, and the squatter is byte-intact.
|
||||||
|
let registrations = git_worktree_list(base.path());
|
||||||
|
assert!(
|
||||||
|
registrations
|
||||||
|
.iter()
|
||||||
|
.any(|l| l == &format!("worktree {}", squatter.canonicalize().unwrap().display())),
|
||||||
|
"operator's worktree must stay registered: {registrations:?}"
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
registrations.iter().any(|l| l.contains("collide-2")),
|
||||||
|
"suffixed worktree must be registered too: {registrations:?}"
|
||||||
|
);
|
||||||
|
|
||||||
|
// Both sessions run inside their own tree at the same time.
|
||||||
|
let sessions = client.list_sessions().await.expect("list");
|
||||||
|
assert!(
|
||||||
|
sessions.iter().any(|x| x.id == s.id && x.cwd == suffixed),
|
||||||
|
"session must keep running in its suffixed tree"
|
||||||
|
);
|
||||||
|
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
client.kill_session(s.id).await.expect("kill");
|
||||||
|
|
||||||
|
// Only the daemon-made trees go; the operator's manual one survives.
|
||||||
|
let after = git_worktree_list(base.path());
|
||||||
|
assert!(
|
||||||
|
after
|
||||||
|
.iter()
|
||||||
|
.any(|l| l == &format!("worktree {}", squatter.canonicalize().unwrap().display())),
|
||||||
|
"operator's worktree must outlive the sessions: {after:?}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// #77/#88: the target path holds a plain directory the daemon never made and
|
||||||
|
/// git has never heard of. The daemon neither adopts it nor errors — it builds
|
||||||
|
/// beside it and leaves every byte of it alone.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn foreign_directory_is_sidestepped_never_adopted() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
|
||||||
|
let squatter = base
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("foreign");
|
||||||
|
std::fs::create_dir_all(&squatter).unwrap();
|
||||||
|
std::fs::write(squatter.join("operator-notes.txt"), b"mine\n").unwrap();
|
||||||
|
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/foreign", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn must sidestep, not adopt or fail");
|
||||||
|
|
||||||
|
let suffixed = base
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("foreign-2");
|
||||||
|
assert_eq!(s.cwd, suffixed, "session must run in the suffixed tree");
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read(squatter.join("operator-notes.txt")).unwrap(),
|
||||||
|
b"mine\n",
|
||||||
|
"the foreign directory must be untouched"
|
||||||
|
);
|
||||||
|
let registrations = git_worktree_list(base.path());
|
||||||
|
let registered_paths: Vec<&str> = registrations
|
||||||
|
.iter()
|
||||||
|
.filter_map(|l| l.strip_prefix("worktree "))
|
||||||
|
.collect();
|
||||||
|
assert!(
|
||||||
|
!registered_paths
|
||||||
|
.iter()
|
||||||
|
.any(|p| *p == squatter.canonicalize().unwrap().display().to_string()),
|
||||||
|
"a plain directory must never be adopted as a worktree: {registered_paths:?}"
|
||||||
|
);
|
||||||
|
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
client.kill_session(s.id).await.expect("kill");
|
||||||
|
assert!(squatter.join("operator-notes.txt").exists());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// #79/#88: killing with uncommitted changes is refused; committing and
|
||||||
|
/// pushing that work clears the guard and the very same kill then succeeds
|
||||||
|
/// and removes the tree. The session is the handle on the work: while it is
|
||||||
|
/// unsaved the session stays, once it is saved the tree goes.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn guarded_kill_then_commit_and_push_makes_the_same_kill_succeed() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
|
||||||
|
let wt = base.path().join("worktrees").join("feature").join("guard");
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/guard", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn");
|
||||||
|
std::fs::write(wt.join("README"), b"work in progress\n").unwrap();
|
||||||
|
|
||||||
|
// Refused: the edit is uncommitted.
|
||||||
|
let err = client
|
||||||
|
.kill_session(s.id)
|
||||||
|
.await
|
||||||
|
.expect_err("kill must refuse");
|
||||||
|
match err {
|
||||||
|
maestro_e2e::ClientError::Api(maestro_protocol::ClientError::Api { info, .. }) => {
|
||||||
|
assert_eq!(info.code, "kill_guarded", "{info:?}");
|
||||||
|
let breakdown = info.unsaved_work.expect("breakdown on the wire");
|
||||||
|
assert_eq!(breakdown.uncommitted_files, 1);
|
||||||
|
assert_eq!(breakdown.unpushed_commits, 0);
|
||||||
|
}
|
||||||
|
other => panic!("expected a kill_guarded refusal, got {other:?}"),
|
||||||
|
}
|
||||||
|
assert!(
|
||||||
|
client
|
||||||
|
.list_sessions()
|
||||||
|
.await
|
||||||
|
.unwrap()
|
||||||
|
.iter()
|
||||||
|
.any(|x| x.id == s.id),
|
||||||
|
"a refused kill keeps the session running"
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read(wt.join("README")).unwrap(),
|
||||||
|
b"work in progress\n",
|
||||||
|
"the worktree is untouched by the refusal"
|
||||||
|
);
|
||||||
|
|
||||||
|
// The operator does exactly what the refusal asked for: save and push.
|
||||||
|
commit_all(&wt, "wip");
|
||||||
|
push_all(base.path());
|
||||||
|
|
||||||
|
client.kill_session(s.id).await.expect("kill after saving");
|
||||||
|
|
||||||
|
let deadline = Instant::now() + Duration::from_secs(5);
|
||||||
|
while Instant::now() < deadline {
|
||||||
|
if !wt.exists() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||||
|
}
|
||||||
|
assert!(
|
||||||
|
!wt.exists(),
|
||||||
|
"a cleared worktree must be removed after kill"
|
||||||
|
);
|
||||||
|
let registrations = git_worktree_list(base.path());
|
||||||
|
assert!(
|
||||||
|
!registrations.iter().any(|l| l.contains("feature/guard")),
|
||||||
|
"removal must deregister the tree: {registrations:?}"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// #81/#88: commits that no remote has refuse the kill; `--force` ends the
|
||||||
|
/// session anyway but RETAINS the worktree — force never destroys blocked
|
||||||
|
/// work, it parks it in the retained store with reason `force-killed`.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn unpushed_commits_block_kill_and_force_retains_the_tree() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
|
||||||
|
let wt = base.path().join("worktrees").join("feature").join("local");
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/local", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn");
|
||||||
|
std::fs::write(wt.join("README"), b"local only\n").unwrap();
|
||||||
|
commit_all(&wt, "not pushed yet");
|
||||||
|
|
||||||
|
// Refused: the commit is on no remote-tracking ref.
|
||||||
|
let err = client
|
||||||
|
.kill_session(s.id)
|
||||||
|
.await
|
||||||
|
.expect_err("kill must refuse");
|
||||||
|
match err {
|
||||||
|
maestro_e2e::ClientError::Api(maestro_protocol::ClientError::Api { info, .. }) => {
|
||||||
|
assert_eq!(info.code, "kill_guarded", "{info:?}");
|
||||||
|
let breakdown = info.unsaved_work.expect("breakdown on the wire");
|
||||||
|
assert_eq!(breakdown.unpushed_commits, 1);
|
||||||
|
assert_eq!(breakdown.uncommitted_files, 0);
|
||||||
|
}
|
||||||
|
other => panic!("expected a kill_guarded refusal, got {other:?}"),
|
||||||
|
}
|
||||||
|
|
||||||
|
// Force overrides the refusal and nothing else: session gone, tree kept.
|
||||||
|
let outcome = client.kill_session_forced(s.id).await.expect("forced kill");
|
||||||
|
let retained = outcome
|
||||||
|
.retained
|
||||||
|
.expect("force must retain the guarded tree");
|
||||||
|
assert_eq!(
|
||||||
|
retained.reason,
|
||||||
|
maestro_protocol::RetainedReason::ForceKilled
|
||||||
|
);
|
||||||
|
assert_eq!(retained.path, wt);
|
||||||
|
assert_eq!(retained.branch, "feature/local");
|
||||||
|
assert_eq!(retained.in_the_way.unpushed_commits, 1);
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
!client
|
||||||
|
.list_sessions()
|
||||||
|
.await
|
||||||
|
.unwrap()
|
||||||
|
.iter()
|
||||||
|
.any(|x| x.id == s.id),
|
||||||
|
"the forced kill ends the session"
|
||||||
|
);
|
||||||
|
assert!(wt.is_dir(), "a force-retained worktree must stay on disk");
|
||||||
|
assert!(
|
||||||
|
git_worktree_list(base.path())
|
||||||
|
.iter()
|
||||||
|
.any(|l| l.contains("feature/local")),
|
||||||
|
"the retained tree stays registered in git"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// #82/#88: a session that exits on its own never reaches the kill path, but
|
||||||
|
/// its worktree follows the same rule. Dirty → retained with reason
|
||||||
|
/// `exited-with-unsaved-work`; pristine → removed, leaving nothing behind.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn natural_exit_settles_dirty_and_pristine_worktrees_differently() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
// Two repos so the two cases cannot see each other's state.
|
||||||
|
let dirty_repo = TempDir::new().unwrap();
|
||||||
|
init_repo(dirty_repo.path());
|
||||||
|
let _origin = throwaway_origin(dirty_repo.path());
|
||||||
|
let pristine_repo = TempDir::new().unwrap();
|
||||||
|
init_repo(pristine_repo.path());
|
||||||
|
let _origin_pristine = throwaway_origin(pristine_repo.path());
|
||||||
|
|
||||||
|
let dirty_wt = dirty_repo
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("messy");
|
||||||
|
let pristine_wt = pristine_repo
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("tidy");
|
||||||
|
|
||||||
|
let _dirty = client
|
||||||
|
.spawn_session(&CreateSessionRequest {
|
||||||
|
cwd: dirty_repo.path().to_path_buf(),
|
||||||
|
command: "sh -c 'echo unsaved > scratch.txt'".into(),
|
||||||
|
env: HashMap::new(),
|
||||||
|
metadata: HashMap::new(),
|
||||||
|
worktree: Some(worktree_spec(dirty_repo.path(), "feature/messy", true)),
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.expect("spawn dirty");
|
||||||
|
let _pristine = client
|
||||||
|
.spawn_session(&create_req_cmd(
|
||||||
|
pristine_repo.path(),
|
||||||
|
"true",
|
||||||
|
"feature/tidy",
|
||||||
|
))
|
||||||
|
.await
|
||||||
|
.expect("spawn pristine");
|
||||||
|
|
||||||
|
assert!(dirty_wt.is_dir() && pristine_wt.is_dir());
|
||||||
|
|
||||||
|
// The watcher reaps dead tmux sessions every couple of ticks and settles
|
||||||
|
// each worktree accordingly. Poll for both outcomes.
|
||||||
|
wait_for_async(
|
||||||
|
"dirty exit retains its worktree",
|
||||||
|
Duration::from_secs(20),
|
||||||
|
|| {
|
||||||
|
let client = client.clone();
|
||||||
|
let path = dirty_wt.clone();
|
||||||
|
async move {
|
||||||
|
client
|
||||||
|
.list_worktrees()
|
||||||
|
.await
|
||||||
|
.ok()
|
||||||
|
.map(|wts| {
|
||||||
|
wts.iter().any(|w| {
|
||||||
|
w.path == path
|
||||||
|
&& w.reason
|
||||||
|
== maestro_protocol::RetainedReason::ExitedWithUnsavedWork
|
||||||
|
})
|
||||||
|
})
|
||||||
|
.unwrap_or(false)
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
wait_for_async(
|
||||||
|
"pristine exit removes its worktree entirely",
|
||||||
|
Duration::from_secs(20),
|
||||||
|
|| {
|
||||||
|
let client = client.clone();
|
||||||
|
let repo = pristine_repo.path().to_path_buf();
|
||||||
|
let path = pristine_wt.clone();
|
||||||
|
async move {
|
||||||
|
if path.exists() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
let listed = client.list_worktrees().await.ok();
|
||||||
|
let listed_clear = listed
|
||||||
|
.map(|wts| !wts.iter().any(|w| w.path == path))
|
||||||
|
.unwrap_or(false);
|
||||||
|
let registered = git_worktree_list(&repo);
|
||||||
|
!registered.iter().any(|l| l.contains("feature/tidy")) && listed_clear
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
|
||||||
|
// The dirty tree is still fully there, file included.
|
||||||
|
assert!(dirty_wt.is_dir());
|
||||||
|
assert_eq!(
|
||||||
|
std::fs::read(dirty_wt.join("scratch.txt")).unwrap(),
|
||||||
|
b"unsaved\n"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn create_req_cmd(cwd: &std::path::Path, command: &str, branch: &str) -> CreateSessionRequest {
|
||||||
|
CreateSessionRequest {
|
||||||
|
cwd: cwd.to_path_buf(),
|
||||||
|
command: command.into(),
|
||||||
|
env: HashMap::new(),
|
||||||
|
metadata: HashMap::new(),
|
||||||
|
worktree: Some(worktree_spec(cwd, branch, true)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// #80/#88: `GET /api/worktrees` lists what the daemon is holding, with the
|
||||||
|
/// reason and a live in-the-way breakdown; reclaim removes the directory and
|
||||||
|
/// the store entry but NEVER the branch — its commits outlive the reclaim.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn worktrees_endpoint_lists_reasons_and_reclaim_keeps_the_branch() {
|
||||||
|
let (_daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
|
||||||
|
let wt = base.path().join("worktrees").join("feature").join("parked");
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/parked", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn");
|
||||||
|
std::fs::write(wt.join("README"), b"worth keeping\n").unwrap();
|
||||||
|
commit_all(&wt, "worth keeping");
|
||||||
|
let sha = branch_sha(&wt, "feature/parked");
|
||||||
|
|
||||||
|
let outcome = client.kill_session_forced(s.id).await.expect("force kill");
|
||||||
|
assert!(outcome.retained.is_some());
|
||||||
|
|
||||||
|
let listed = client.list_worktrees().await.expect("list worktrees");
|
||||||
|
assert_eq!(listed.len(), 1, "exactly one retained entry: {listed:?}");
|
||||||
|
let entry = &listed[0];
|
||||||
|
assert_eq!(entry.path, wt);
|
||||||
|
assert_eq!(entry.branch, "feature/parked");
|
||||||
|
assert_eq!(entry.reason, maestro_protocol::RetainedReason::ForceKilled);
|
||||||
|
assert_eq!(entry.in_the_way.unpushed_commits, 1);
|
||||||
|
|
||||||
|
client.reclaim_worktree(entry.id).await.expect("reclaim");
|
||||||
|
assert!(!wt.exists(), "reclaim removes the directory");
|
||||||
|
assert!(
|
||||||
|
client.list_worktrees().await.unwrap().is_empty(),
|
||||||
|
"reclaim drops the store entry"
|
||||||
|
);
|
||||||
|
|
||||||
|
// The whole point of reclaim: the branch and its commits survive.
|
||||||
|
assert_eq!(
|
||||||
|
branch_sha(base.path(), "feature/parked"),
|
||||||
|
sha,
|
||||||
|
"the branch must keep pointing at the same commit after reclaim"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The retained store is state-dir backed (#80): a daemon restart must not
|
||||||
|
/// orphan the trees it is holding — they are still on disk with entries
|
||||||
|
/// pointing at them, and still reclaimable afterwards.
|
||||||
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
|
async fn retained_store_survives_a_daemon_restart() {
|
||||||
|
let (mut daemon, client) = bring_up().await;
|
||||||
|
|
||||||
|
let base = TempDir::new().unwrap();
|
||||||
|
init_repo(base.path());
|
||||||
|
let _origin = throwaway_origin(base.path());
|
||||||
|
|
||||||
|
let wt = base
|
||||||
|
.path()
|
||||||
|
.join("worktrees")
|
||||||
|
.join("feature")
|
||||||
|
.join("durable");
|
||||||
|
let s = client
|
||||||
|
.spawn_session(&worktree_req(base.path(), "feature/durable", true))
|
||||||
|
.await
|
||||||
|
.expect("spawn");
|
||||||
|
std::fs::write(wt.join("README"), b"survives restarts\n").unwrap();
|
||||||
|
commit_all(&wt, "survives restarts");
|
||||||
|
client.kill_session_forced(s.id).await.expect("force kill");
|
||||||
|
|
||||||
|
daemon.restart().await;
|
||||||
|
|
||||||
|
let listed = client.list_worktrees().await.expect("list after restart");
|
||||||
|
assert_eq!(listed.len(), 1, "store must survive restart: {listed:?}");
|
||||||
|
assert_eq!(listed[0].path, wt);
|
||||||
|
assert_eq!(
|
||||||
|
listed[0].reason,
|
||||||
|
maestro_protocol::RetainedReason::ForceKilled
|
||||||
|
);
|
||||||
|
assert!(wt.is_dir(), "the tree itself must survive the restart too");
|
||||||
|
|
||||||
|
client
|
||||||
|
.reclaim_worktree(listed[0].id)
|
||||||
|
.await
|
||||||
|
.expect("reclaim");
|
||||||
|
assert!(!wt.exists());
|
||||||
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// GET /api/projects + /api/branches (#54/#55/#66)
|
// GET /api/projects + /api/branches (#54/#55/#66)
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
@@ -788,10 +1251,12 @@ fn git_worktree_list(dir: &std::path::Path) -> Vec<String> {
|
|||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Push every branch of `repo` to a throwaway bare remote, so its commits are
|
/// Bare remote registered as `origin` on `repo`, seeded with every current
|
||||||
/// reachable from remote-tracking refs. Without one the kill guard (#79)
|
/// branch, so existing commits are reachable from remote-tracking refs.
|
||||||
/// reads every commit as unpushed, and any worktree session refuses to die.
|
/// Without one the kill guard (#79) reads every commit as unpushed, and any
|
||||||
fn push_to_throwaway_origin(repo: &std::path::Path) {
|
/// worktree session refuses to die. The caller must keep the `TempDir` alive
|
||||||
|
/// while the remote is still needed; later pushes go through [`push_all`].
|
||||||
|
fn throwaway_origin(repo: &std::path::Path) -> TempDir {
|
||||||
let origin = tempfile::TempDir::new().unwrap();
|
let origin = tempfile::TempDir::new().unwrap();
|
||||||
run_git(
|
run_git(
|
||||||
&["init", "-q", "--bare", origin.path().to_str().unwrap()],
|
&["init", "-q", "--bare", origin.path().to_str().unwrap()],
|
||||||
@@ -803,9 +1268,34 @@ fn push_to_throwaway_origin(repo: &std::path::Path) {
|
|||||||
.args(["remote", "add", "origin", origin.path().to_str().unwrap()])
|
.args(["remote", "add", "origin", origin.path().to_str().unwrap()])
|
||||||
.output()
|
.output()
|
||||||
.expect("git remote add");
|
.expect("git remote add");
|
||||||
|
push_all(repo);
|
||||||
|
origin
|
||||||
|
}
|
||||||
|
|
||||||
|
fn push_all(repo: &std::path::Path) {
|
||||||
run_git(&["push", "-q", "--all", "origin"], repo);
|
run_git(&["push", "-q", "--all", "origin"], repo);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn commit_all(dir: &std::path::Path, message: &str) {
|
||||||
|
run_git(&["add", "-A"], dir);
|
||||||
|
run_git(&["commit", "-q", "-m", message], dir);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn branch_sha(repo: &std::path::Path, branch: &str) -> String {
|
||||||
|
let out = Command::new("git")
|
||||||
|
.arg("-C")
|
||||||
|
.arg(repo)
|
||||||
|
.args(["rev-parse", "--verify", &format!("refs/heads/{branch}")])
|
||||||
|
.output()
|
||||||
|
.expect("git rev-parse");
|
||||||
|
assert!(
|
||||||
|
out.status.success(),
|
||||||
|
"branch {branch} missing: {}",
|
||||||
|
String::from_utf8_lossy(&out.stderr)
|
||||||
|
);
|
||||||
|
String::from_utf8_lossy(&out.stdout).trim().to_string()
|
||||||
|
}
|
||||||
|
|
||||||
#[tokio::test(flavor = "multi_thread")]
|
#[tokio::test(flavor = "multi_thread")]
|
||||||
async fn daemon_events_ws_streams_snapshot_then_session_added() {
|
async fn daemon_events_ws_streams_snapshot_then_session_added() {
|
||||||
// NAP-248: subscribe to the daemon's WS /api/events, expect an initial
|
// NAP-248: subscribe to the daemon's WS /api/events, expect an initial
|
||||||
|
|||||||
@@ -97,6 +97,17 @@ Nobody is waiting for an answer here, so there is nothing to refuse; the choice
|
|||||||
only between removing and retaining. It uses the same predicate as the kill, from
|
only between removing and retaining. It uses the same predicate as the kill, from
|
||||||
the same place, so the two paths cannot drift apart.
|
the same place, so the two paths cannot drift apart.
|
||||||
|
|
||||||
|
The session itself stays in the catalog marked dead until it is dismissed — the
|
||||||
|
replay buffer of a crashed agent outlives it — but its worktree is settled at
|
||||||
|
once. Once settled, the session drops its worktree reference, so dismissing it
|
||||||
|
afterwards neither refuses (there is no guard left to trip) nor records a second
|
||||||
|
store entry.
|
||||||
|
|
||||||
|
If settling is impossible — the probe fails, or the store cannot take the entry —
|
||||||
|
nothing is destroyed. The tree stays on disk *and* stays attached to the dead
|
||||||
|
record, where dismissing it later still goes through `--force`'s
|
||||||
|
retain-before-teardown path. Losing the store must never mean losing the work.
|
||||||
|
|
||||||
## The retained store
|
## The retained store
|
||||||
|
|
||||||
A `state_dir`-backed record of worktrees the daemon created that no longer have a
|
A `state_dir`-backed record of worktrees the daemon created that no longer have a
|
||||||
|
|||||||
Reference in New Issue
Block a user