fix(runtime): clean up sessions on disconnect (#17)

* fix(runtime): clean up sessions on disconnect

* chore(ci): match Biome 2.4 formatting

* ci: retry stalled Rust job

* test: bind daemon ports without probe races
This commit is contained in:
NianJiu authored and GitHub committed 2026-08-12 18:44:22 +08:00
1 parent c75f97119d
commit 1371c92721
8 files changed
+261 -24

No files matched your search

+3 -4
View File
@@ -539,10 +539,9 @@ pub async fn stop_session(
Ok(result)
}
Err(DispatchError::Rpc(err)) => {
// After an extension SW restart the daemon still owns the
// session entry (the generation-guard ensures we do not
// purge across reconnects), but the extension's in-memory
// SessionManager is reset and now answers `not_found`.
// A legacy extension or an unusual reconnect race may still
// leave a daemon session after the extension's in-memory
// SessionManager has reset and now answers `not_found`.
// Treat that as an authoritative signal that the session is
// already gone and reconcile our local state instead of
// leaving an orphan row visible to `bsk session list`
+11
View File
@@ -286,6 +286,17 @@ async fn drive_connection(
// socket's cleanup path uses `remove_if_generation_matches` to
// avoid clobbering the newer entry (review M4/M5 round 2 #1).
let browser_id = BrowserId(params.instance_id.clone());
// A fresh socket represents a fresh extension control plane. The
// extension tears down its local sessions before reconnecting, so any
// daemon-side sessions left under the same instance id are stale. Purge
// them before replacing the browser registration; otherwise an old WS
// cleanup racing with this handshake can preserve rows that no longer
// have an Agent Window on the extension side.
for session in state.sessions.purge_browser(&browser_id) {
state.tool_queues.remove(&session.id);
state.session_interrupts.drop_session(&session.id);
debug!(session = %session.id, "purged stale session before browser reconnect");
}
let (tx, mut rx) = mpsc::unbounded_channel::<Frame>();
let generation = super::browsers::next_browser_generation();
let connected_at_ms = std::time::SystemTime::now()
+14 -16
View File
@@ -19,7 +19,7 @@ use tokio_tungstenite::tungstenite::handshake::client::generate_key;
use tokio_tungstenite::tungstenite::http::Request;
use tokio_tungstenite::tungstenite::protocol::Message;
use support::{wait_for_browser_count, wait_for_no_sessions, wait_for_session_count};
use support::{wait_for_browser_count, wait_for_no_sessions};
const TEST_EXT_ID: &str = "abcdefghijklmnopabcdefghijklmnop";
@@ -728,11 +728,10 @@ async fn browser_disconnect_purges_sessions() {
#[tokio::test]
async fn session_stop_self_heals_when_extension_reports_not_found() {
// After an extension SW restart the daemon still owns the session
// entry (Round 2 generation-guard) but the extension's
// SessionManager is reset and answers `not_found`. Stop must
// reconcile local state so `session.list` does not show an orphan
// (review M4/M5 round 3 I-R3-2).
// Legacy extension versions or unusual reconnect races can leave a
// daemon session after the extension's SessionManager resets and answers
// `not_found`. Stop must still reconcile local state so `session.list`
// does not show an orphan (review M4/M5 round 3 I-R3-2).
let (handle, sock) = spawn_daemon().await;
let mut ws = connect_ext(handle.ws_addr()).await;
@@ -826,14 +825,13 @@ async fn session_stop_self_heals_when_extension_reports_not_found() {
}
#[tokio::test]
async fn reconnect_with_same_instance_id_does_not_clobber_new_browser() {
async fn reconnect_with_same_instance_id_purges_stale_sessions_but_keeps_new_browser() {
// Spawn a daemon, connect ext A, register a session bound to it,
// then connect ext B reusing the same instance_id (mimics a SW
// restart / WS reconnect under MV3). When the OLD WS task tears
// down, the generation guard MUST keep the new entry + its
// session in the registry. Without the guard the stale cleanup
// path would call browsers.remove() + sessions.purge_browser()
// and the daemon would silently drop the live session.
// restart / WS reconnect under MV3). The extension now safely stops
// its local sessions before reconnecting, so the new handshake must
// purge the matching daemon rows. The generation guard must still keep
// the NEW browser registration when the old WS task later tears down.
let (handle, _sock) = spawn_daemon().await;
let mut ws_a = connect_ext(handle.ws_addr()).await;
@@ -854,14 +852,14 @@ async fn reconnect_with_same_instance_id_does_not_clobber_new_browser() {
let _ = handshake_as_ext(&mut ws_b).await;
// Registry now holds the newer generation under the same id.
assert_eq!(state.browsers.len(), 1);
wait_for_no_sessions(&state).await;
// Tear down ext A only; the cleanup path will run but must
// observe that the registered generation no longer matches and
// leave the new entry + session alone.
// leave the new browser entry alone.
let _ = ws_a.close(None).await;
drop(ws_a);
wait_for_browser_count(&state, 1).await;
wait_for_session_count(&state, 1).await;
assert_eq!(
state.browsers.len(),
@@ -870,8 +868,8 @@ async fn reconnect_with_same_instance_id_does_not_clobber_new_browser() {
);
assert_eq!(
state.sessions.len(),
1,
"session must survive old browser cleanup"
0,
"stale sessions must not survive reconnect"
);
let _ = ws_b.close(None).await;