Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

85.6 KB
Raw Blame
//! HTTP boundary for the same Core debugger used by desktop commands.

use std::sync::Arc;

use axum::extract::State;
use axum::http::{HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use axum::{Json, Router};
use dbx_core::query::pl_debug::{
    self, PlDebugAccess, PlDebugCompile, PlDebugCompileRef, PlDebugInspect, PlDebugMutationPermit,
    PlDebugMutationScope, PlDebugOperation, PlDebugRead, PlDebugReceipt, PlDebugSessionRef, PlDebugStart,
};
use serde::Deserialize;
use serde_json::Value;
use uuid::Uuid;

use crate::{auth, error::AppError, state::WebState};

pub fn router() -> Router<Arc<WebState>> {
    Router::new()
        .route("/pl-debug/bootstrap", post(bootstrap))
        .route("/pl-debug/inspect", post(inspect))
        .route("/pl-debug/compile", post(compile))
        .route("/pl-debug/compile-status", post(compile_status))
        .route("/pl-debug/list", post(list))
        .route("/pl-debug/start", post(start))
        .route("/pl-debug/status", post(status))
        .route("/pl-debug/heartbeat", post(heartbeat))
        .route("/pl-debug/operation", post(operation))
        .route("/pl-debug/operate", post(operate))
        .route("/pl-debug/read", post(read))
}

async fn access(state: &WebState, headers: &HeaderMap) -> Result<PlDebugAccess, AppError> {
    validated_access(&*state.sessions.read().await, headers)
}

fn validated_access(
    sessions: &std::collections::HashSet<String>,
    headers: &HeaderMap,
) -> Result<PlDebugAccess, AppError> {
    let token = auth::session_token_from_headers(headers)
        .ok_or_else(|| AppError::forbidden("PL debug browser session is not available"))?;
    if !sessions.contains(&token) {
        return Err(AppError::forbidden("PL debug browser session is not available"));
    }
    // The existing middleware owns credential scope. In password-disabled mode
    // it stays None; the browser token only isolates debugger access.
    PlDebugAccess::web(token).map_err(AppError::from)
}

pub(crate) async fn claim_mutation<'a>(
    state: &'a WebState,
    headers: &HeaderMap,
    scope: PlDebugMutationScope,
) -> Result<PlDebugMutationPermit<'a>, AppError> {
    let sessions = state.sessions.read().await;
    let access = auth::session_token_from_headers(headers)
        .filter(|token| sessions.contains(token))
        .map(PlDebugAccess::web)
        .transpose()?;
    pl_debug::pl_debug_claim_mutation_core(&state.app, access.as_ref(), scope).map_err(AppError::forbidden)
}

async fn bootstrap(State(state): State<Arc<WebState>>, headers: HeaderMap) -> Result<Response, AppError> {
    if !state.password_disabled {
        access(&state, &headers).await?;
        return Ok(Json(pl_debug::pl_debug_bootstrap_core(&state.app)).into_response());
    }
    let supplied = auth::session_token_from_headers(&headers);
    let mut sessions = state.sessions.write().await;
    if supplied.as_ref().is_some_and(|token| sessions.contains(token)) {
        return Ok(Json(pl_debug::pl_debug_bootstrap_core(&state.app)).into_response());
    }
    let token = Uuid::new_v4().to_string();
    sessions.insert(token.clone());
    drop(sessions);
    let cookie = auth::session_cookie(&state, &token);
    Ok((StatusCode::OK, [("set-cookie", cookie)], Json(pl_debug::pl_debug_bootstrap_core(&state.app))).into_response())
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct ListRequest {
    server_epoch: Uuid,
    connection_id: String,
}

async fn list(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<ListRequest>,
) -> Result<Json<Vec<Value>>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(pl_debug::pl_debug_list_core(&state.app, &owner, request.server_epoch, &request.connection_id)?))
}

async fn inspect(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<PlDebugInspect>,
) -> Result<Json<Value>, AppError> {
    let owner = access(&state, &headers).await?;
    let result = match pl_debug::pl_debug_prepare_inspection_core(&state.app, &request).await? {
        Some(admission) => {
            let sessions = state.sessions.read().await;
            let owner = validated_access(&sessions, &headers)?;
            let submission = pl_debug::pl_debug_submit_inspection_core(&state.app, &owner, admission)?;
            drop(sessions);
            submission.wait().await
        }
        None => pl_debug::pl_debug_inspect_core(&state.app, &owner, request).await,
    };
    access(&state, &headers).await?;
    Ok(Json(result?))
}

async fn start(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<PlDebugStart>,
) -> Result<Json<PlDebugReceipt>, AppError> {
    // Registration and revocation share this short boundary. No RPC is awaited
    // while holding the auth lock, and logout cannot miss a just-accepted start.
    let sessions = state.sessions.read().await;
    let owner = validated_access(&sessions, &headers)?;
    Ok(Json(
        pl_debug::pl_debug_start_submission_core(&state.app, &owner, request)
            .map_err(|error| AppError::from(error.into_backend_error()))?,
    ))
}

async fn compile(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<PlDebugCompile>,
) -> Result<Json<Value>, AppError> {
    let owner = access(&state, &headers).await?;
    let admission = pl_debug::pl_debug_prepare_compile_core(&state.app, &owner, request)
        .await
        .map_err(|error| AppError::from(error.into_backend_error()))?;
    submit_prepared_compilation(&state, &headers, admission).await
}

async fn submit_prepared_compilation(
    state: &WebState,
    headers: &HeaderMap,
    admission: pl_debug::PlDebugCompileAdmission,
) -> Result<Json<Value>, AppError> {
    let sessions = state.sessions.read().await;
    let owner = validated_access(&sessions, headers)?;
    Ok(Json(
        pl_debug::pl_debug_submit_compile_core(&state.app, &owner, admission)
            .map_err(|error| AppError::from(error.into_backend_error()))?,
    ))
}

async fn compile_status(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(reference): Json<PlDebugCompileRef>,
) -> Result<Json<Value>, AppError> {
    let sessions = state.sessions.read().await;
    let owner = validated_access(&sessions, &headers)?;
    Ok(Json(pl_debug::pl_debug_compile_status_core(&state.app, &owner, reference)?))
}

#[derive(Deserialize)]
struct StatusRequest {
    reference: PlDebugSessionRef,
    #[serde(default)]
    refresh: bool,
}

async fn status(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<StatusRequest>,
) -> Result<Json<Value>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(pl_debug::pl_debug_status_core(&state.app, &owner, &request.reference, request.refresh).await?))
}

async fn heartbeat(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(reference): Json<PlDebugSessionRef>,
) -> Result<Json<Value>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(pl_debug::pl_debug_heartbeat_core(&state.app, &owner, &reference).await?))
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct OperationRequest {
    reference: PlDebugSessionRef,
    operation_id: String,
}

async fn operation(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<OperationRequest>,
) -> Result<Json<PlDebugReceipt>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(pl_debug::pl_debug_operation_core(&state.app, &owner, &request.reference, &request.operation_id)?))
}

async fn operate(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<PlDebugOperation>,
) -> Result<Json<PlDebugReceipt>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(
        pl_debug::pl_debug_operate_submission_core(&state.app, &owner, request)
            .await
            .map_err(|error| AppError::from(error.into_backend_error()))?,
    ))
}

async fn read(
    State(state): State<Arc<WebState>>,
    headers: HeaderMap,
    Json(request): Json<PlDebugRead>,
) -> Result<Json<Value>, AppError> {
    let owner = access(&state, &headers).await?;
    Ok(Json(pl_debug::pl_debug_read_core(&state.app, &owner, request).await?))
}

#[cfg(test)]
mod tests {
    use super::*;
    use axum::{middleware, routing::get};
    use serde_json::json;

    struct TestServer {
        address: std::net::SocketAddr,
        task: tokio::task::JoinHandle<()>,
    }
    impl TestServer {
        async fn post(&self, path: &str, cookie: Option<&str>, body: Value) -> reqwest::Response {
            let mut request = reqwest::Client::new().post(format!("http://{}{path}", self.address)).json(&body);
            if let Some(cookie) = cookie {
                request = request.header("cookie", cookie);
            }
            request.send().await.unwrap()
        }
    }
    impl Drop for TestServer {
        fn drop(&mut self) {
            self.task.abort();
        }
    }

    async fn fixture(disabled: bool) -> (tempfile::TempDir, Arc<WebState>, TestServer) {
        let directory = tempfile::tempdir().unwrap();
        let storage = dbx_core::persistence::test_storage::open(&directory.path().join("storage.db")).await.unwrap();
        let app = Arc::new(dbx_core::connection::AppState::new_with_plugin_and_agent_dir_and_app_version(
            storage,
            directory.path().join("plugins"),
            directory.path().join("agents"),
            "test",
        ));
        let mut state = WebState::for_tests(app, directory.path().to_path_buf());
        state.password_disabled = disabled;
        if !disabled {
            *state.password_hash.get_mut() = Some("configured".into());
        }
        let state = Arc::new(state);
        let routes = router()
            .route("/auth/logout", post(auth::logout))
            .route("/auth/change-password", post(auth::change_password))
            .route("/connection/disconnect", post(crate::routes::connection::disconnect_db))
            .route("/connection/connect", post(crate::routes::connection::connect_db))
            .route("/connection/final-proxy-port", post(crate::routes::connection::connection_final_proxy_port))
            .route("/connection/save", post(crate::routes::connection::save_connections))
            .route("/connection/list", get(crate::routes::connection::load_connections))
            .route("/connection/mcp/remove", post(crate::routes::connection::mcp_remove_connection))
            .route("/connection/mcp/add", post(crate::routes::connection::mcp_add_connection))
            .route("/connection/mcp/duplicate", post(crate::routes::connection::mcp_duplicate_connection))
            .route("/connection/write-unlock", post(crate::routes::connection::unlock_connection_writes))
            .route("/connection/write-unlock/lock", post(crate::routes::connection::lock_connection_writes))
            .route("/connection/write-unlock/state", post(crate::routes::connection::connection_write_unlock_state))
            .route("/tunnel-profiles/save", post(crate::routes::tunnel_profiles::save_tunnel_profiles))
            .route("/agents/runtime/stop", post(crate::routes::agents::stop_driver_runtime))
            .route("/agents/runtime/restart", post(crate::routes::agents::restart_driver_runtime))
            .route("/agents/java-runtime", post(crate::routes::agents::set_agent_java_runtime_config))
            .layer(middleware::from_fn_with_state(state.clone(), auth::auth_middleware))
            .with_state(state.clone());
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let task = tokio::spawn(async move { axum::serve(listener, routes).await.unwrap() });
        (directory, state, TestServer { address, task })
    }

    #[tokio::test]
    async fn password_disabled_bootstrap_issues_and_reuses_a_server_browser_token() {
        let (_directory, state, routes) = fixture(true).await;
        let first = routes.post("/pl-debug/bootstrap", Some("dbx_session=untrusted"), serde_json::json!({})).await;
        assert_eq!(first.status(), StatusCode::OK);
        let cookie = first.headers()["set-cookie"].to_str().unwrap().to_string();
        assert!(cookie.contains("HttpOnly") && cookie.contains("SameSite=Lax"));
        let token = cookie.split(';').next().unwrap();
        assert_ne!(token, "dbx_session=untrusted");
        assert_eq!(state.sessions.read().await.len(), 1);
        let bootstrap: Value = first.json().await.unwrap();
        let list_body = serde_json::json!({"serverEpoch":bootstrap["serverEpoch"],"connectionId":"conn"});
        let denied = routes.post("/pl-debug/list", Some("dbx_session=untrusted"), list_body.clone()).await;
        assert_eq!(denied.status(), StatusCode::FORBIDDEN);
        let denied_inspect = routes
            .post(
                "/pl-debug/inspect",
                Some("dbx_session=untrusted"),
                serde_json::json!({
                    "connectionId":"conn", "database":"APP", "clientSessionId":"editor"
                }),
            )
            .await;
        assert_eq!(denied_inspect.status(), StatusCode::FORBIDDEN);
        let reused = routes.post("/pl-debug/bootstrap", Some(token), serde_json::json!({})).await;
        assert!(reused.headers().get("set-cookie").is_none());
        assert_eq!(state.sessions.read().await.len(), 1);
        let allowed = routes.post("/pl-debug/list", Some(token), list_body.clone()).await;
        assert_eq!(allowed.status(), StatusCode::OK);
        state.sessions.write().await.clear();
        let revoked = routes.post("/pl-debug/list", Some(token), list_body).await;
        assert_eq!(revoked.status(), StatusCode::FORBIDDEN);
    }

    #[tokio::test]
    async fn password_enabled_bootstrap_requires_existing_authenticated_session() {
        let (_directory, state, routes) = fixture(false).await;
        let denied = routes.post("/pl-debug/bootstrap", None, serde_json::json!({})).await;
        assert_eq!(denied.status(), StatusCode::UNAUTHORIZED);
        assert!(state.sessions.read().await.is_empty());
        state.sessions.write().await.insert("validated-login".into());
        let allowed =
            routes.post("/pl-debug/bootstrap", Some("dbx_session=validated-login"), serde_json::json!({})).await;
        assert_eq!(allowed.status(), StatusCode::OK);
        assert!(allowed.headers().get("set-cookie").is_none());
        assert_eq!(state.sessions.read().await.len(), 1);
    }

    async fn configure_agent(state: &WebState, routes: &TestServer) {
        let driver = state.app.agent_manager.driver_dir("oracle");
        std::fs::create_dir_all(&driver).unwrap();
        std::fs::write(driver.join("agent.py"), r#"import json, os, pathlib, sys, threading, time
root=pathlib.Path(__file__).parent
snapshot={'state':'paused','stopRevision':1,'executionStopped':False,'executionOutcome':'pending','releaseState':'open','transactionOutcome':'pending','targetDispatched':True}
compile_receipt={}
threading.Timer(30,lambda:os._exit(9)).start()
def event(method):
    with open(root/'events','a',encoding='utf-8') as f: f.write(json.dumps({'method':method,'scope':os.environ.get('DBX_PL_DEBUG_RUNTIME_SCOPE')})+'\n')
print(json.dumps({'ready':True}),flush=True)
for line in sys.stdin:
    req=json.loads(line); method=req['method']; event(method)
    if method=='handshake': result={'protocolVersion':2,'agentProtocolVersion':2,'capabilities':['multi_session','structured_error_v1'],'plDebug':{'contractVersion':1,'helperObjects':False}}
    elif method=='open_session':
        scope={'anonymous-secret':'default','first-secret':'first','second-secret':'second'}.get(req['params'].get('password'),'wrong')
        event('credential_'+scope); result={'ok':True}
    elif method=='pl_debug_inspect':
        while (root/'delay-inspect').exists() and not (root/'inspect-gate').exists(): time.sleep(0.01)
        result={'capabilities':{'canAttemptStart':True,'startVerified':False},'targetPreview':{'state':'available','candidates':[]}}
        if (req['params'].get('target') or {}).get('metadataPreparation')=='debug_compile':
            result['compilePreview']={'schema':'APP','objectName':'P','objectType':'PROCEDURE','sql':'ALTER PROCEDURE "APP"."P" COMPILE DEBUG REUSE SETTINGS','reusesSettings':True,'sources':[],'canCompile':True,'state':'available'}
    elif method=='pl_debug_compile':
        compile_receipt={'operationId':req['params']['operationId'],'dispatched':True,'ddlState':'executed','finished':True,'readback':{'status':'INVALID','diagnosticsComplete':True,'diagnostics':[{'text':'fixture diagnostic'}]}}
        while (root/'delay-compile').exists() and not (root/'compile-gate').exists(): time.sleep(0.01)
        result=compile_receipt
    elif method=='pl_debug_compile_status': result=compile_receipt
    elif method=='close_session': result={'ok':True}
    elif method=='pl_debug_start': snapshot['debugId']=req['params']['operationId']; result=snapshot
    elif method=='pl_debug_close':
        while (root/'delay-close').exists() and not (root/'close-gate').exists(): time.sleep(0.01)
        snapshot.update(state='ended',executionStopped=True,executionOutcome='cancelled',releaseState='released',transactionOutcome='rolled_back'); result=True
    elif method=='pl_debug_get_log': result={**snapshot,'output':'private output','outputComplete':True}
    else: result=snapshot
    print(json.dumps({'jsonrpc':'2.0','id':req['id'],'result':result}),flush=True)
    if method=='shutdown': os._exit(0)
"#).unwrap();
        std::fs::write(
            state.app.agent_manager.driver_launch_config_path("oracle"),
            serde_json::json!({
                "command":if cfg!(windows) {"python"} else {"python3"},
                "args":["{driver_dir}/agent.py"],"working_dir":"{driver_dir}"
            })
            .to_string(),
        )
        .unwrap();
        let config = serde_json::from_value(serde_json::json!({
            "id":"conn","name":"Debug fixture","db_type":"oracle","host":"127.0.0.1",
            "port":routes.address.port(),"username":"fixture","password":"","database":"xe","save_password":false
        }))
        .unwrap();
        state.app.configs.write().await.insert("conn".into(), config);
        state.app.session_credentials.set("", "conn", "anonymous-secret");
        for owner in ["first", "second"] {
            state.app.session_credentials.set(owner, "conn", &format!("{owner}-secret"));
        }
    }

    fn events(state: &WebState, method: &str) -> usize {
        std::fs::read_to_string(state.app.agent_manager.driver_dir("oracle").join("events"))
            .unwrap_or_default()
            .lines()
            .filter(|line| serde_json::from_str::<Value>(line).unwrap()["method"] == method)
            .count()
    }

    async fn wait_events(state: &WebState, method: &str, count: usize) {
        tokio::time::timeout(std::time::Duration::from_secs(10), async {
            while events(state, method) < count {
                tokio::time::sleep(std::time::Duration::from_millis(10)).await;
            }
        })
        .await
        .unwrap_or_else(|_| panic!("expected {count} {method} events, got {}", events(state, method)));
    }

    async fn start_session(state: &WebState, routes: &TestServer, owner: &str) -> Value {
        start_session_at(state, routes, owner, "conn").await
    }

    async fn start_session_at(state: &WebState, routes: &TestServer, owner: &str, connection_id: &str) -> Value {
        state.sessions.write().await.insert(owner.into());
        let cookie = format!("dbx_session={owner}");
        let bootstrap: Value =
            routes.post("/pl-debug/bootstrap", Some(&cookie), serde_json::json!({})).await.json().await.unwrap();
        let started = routes
            .post(
                "/pl-debug/start",
                Some(&cookie),
                serde_json::json!({
                    "serverEpoch":bootstrap["serverEpoch"],"operationId":format!("start-{owner}"),"connectionId":connection_id,
                    "database":"APP","clientSessionId":"editor","target":{"source":"BEGIN NULL; END;"},
                    "riskAccepted":true,"productionConfirmed":false
                }),
            )
            .await;
        assert_eq!(started.status(), StatusCode::OK);
        let receipt: Value = started.json().await.unwrap();
        let reference = serde_json::json!({"serverEpoch":bootstrap["serverEpoch"],"sessionId":receipt["sessionId"],
            "connectionId":connection_id,"clientSessionId":"editor"});
        tokio::time::timeout(std::time::Duration::from_secs(10), async {
            loop {
                let status: Value = routes
                    .post("/pl-debug/status", Some(&cookie), serde_json::json!({"reference":reference}))
                    .await
                    .json()
                    .await
                    .unwrap();
                if status["state"] == "paused" {
                    break;
                }
                assert_ne!(status["state"], "ended", "{status}");
                tokio::time::sleep(std::time::Duration::from_millis(10)).await;
            }
        })
        .await
        .unwrap();
        reference
    }

    #[tokio::test]
    async fn admission_http_distinguishes_new_rejections_from_owner_and_epoch_failures() {
        let (_directory, state, routes) = fixture(false).await;
        configure_agent(&state, &routes).await;
        state.sessions.write().await.extend(["first".into(), "second".into()]);
        let cookie = Some("dbx_session=first");
        let bootstrap: Value = routes.post("/pl-debug/bootstrap", cookie, json!({})).await.json().await.unwrap();
        let rejected_start: Value = routes
            .post(
                "/pl-debug/start",
                cookie,
                json!({
                    "serverEpoch":bootstrap["serverEpoch"],"operationId":"stale-preview","connectionId":"conn",
                    "database":"APP","clientSessionId":"editor","target":{"source":"BEGIN NULL; END;"},
                    "riskAccepted":true,"productionConfirmed":false,"expectedConnectionRevision":"stale"
                }),
            )
            .await
            .json()
            .await
            .unwrap();
        let starts_before = events(&state, "pl_debug_start");
        let reference = start_session(&state, &routes, "first").await;
        let status: Value =
            routes.post("/pl-debug/status", cookie, json!({"reference":reference})).await.json().await.unwrap();
        let mut request = reference.clone();
        let object = request.as_object_mut().unwrap();
        object.insert("operationId".into(), json!("stale-control"));
        object.insert("generation".into(), status["generation"].clone());
        object.insert("expectedRevision".into(), json!(status["revision"].as_u64().unwrap() + 1));
        object.insert("action".into(), json!("step_over"));
        let stale: Value = routes.post("/pl-debug/operate", cookie, request.clone()).await.json().await.unwrap();
        request["expectedRevision"] = status["revision"].clone();
        state.app.configs.write().await.get_mut("conn").unwrap().read_only = true;
        let protected: Value = routes.post("/pl-debug/operate", cookie, request.clone()).await.json().await.unwrap();
        let foreign: Value =
            routes.post("/pl-debug/operate", Some("dbx_session=second"), request.clone()).await.json().await.unwrap();
        request["serverEpoch"] = json!(Uuid::new_v4());
        let epoch: Value = routes.post("/pl-debug/operate", cookie, request).await.json().await.unwrap();
        let controls = events(&state, "pl_debug_step_over");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        for rejection in [rejected_start, stale, protected] {
            assert_eq!(rejection["code"], "DBX-PLDEBUG-1001", "{rejection}");
            assert_eq!(rejection["operationOutcome"], "not_started");
            assert_eq!(rejection["origin"], json!({"subsystem":"backend","adapter":"legacy"}));
        }
        for unresolved in [foreign, epoch] {
            assert_ne!(unresolved["code"], "DBX-PLDEBUG-1001");
            assert_eq!(unresolved["operationOutcome"], "unknown");
        }
        assert_eq!(starts_before, 0);
        assert_eq!(controls, 0);
    }

    #[tokio::test]
    async fn profile_save_protects_original_sources_after_runtime_configuration_replacement_or_removal() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            for remove_config in [false, true] {
                let (_directory, state, routes) = fixture(disabled).await;
                configure_agent(&state, &routes).await;
                let profile: dbx_core::models::connection::TransportLayerConfig =
                    serde_json::from_value(serde_json::json!({
                        "type":"proxy","id":"shared","name":"Shared","enabled":true,"proxy_type":"socks5",
                        "host":"127.0.0.1","port":65000,"username":"","password":"original-secret"
                    }))
                    .unwrap();
                state.app.storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
                let mut reference = serde_json::to_value(&profile).unwrap();
                reference["id"] = serde_json::json!("reference");
                reference["profile_id"] = serde_json::json!("shared");
                state.app.configs.write().await.get_mut("conn").unwrap().transport_layers =
                    vec![serde_json::from_value(reference).unwrap()];
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                if remove_config {
                    state.app.configs.write().await.remove("conn");
                } else {
                    state.app.configs.write().await.get_mut("conn").unwrap().transport_layers.clear();
                }
                let mut changed = serde_json::to_value(&profile).unwrap();
                changed["password"] = serde_json::json!("changed-secret");
                let response =
                    routes.post("/tunnel-profiles/save", cookie, serde_json::json!({"profiles":[changed]})).await;
                let unchanged = state.app.storage.load_tunnel_profiles().await.unwrap() == vec![profile];
                let closes = events(&state, "pl_debug_close");
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
                outcomes.push((disabled, cookie.is_some(), remove_config, response.status(), unchanged, closes));
            }
        }
        assert!(
            outcomes.iter().all(|(_, _, _, status, unchanged, closes)| {
                *status == StatusCode::FORBIDDEN && *unchanged && *closes == 0
            }),
            "{outcomes:?}"
        );
    }

    #[tokio::test]
    async fn profile_save_cannot_delete_another_owners_orphan_or_extra_secret_rows() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            for orphan in [false, true] {
                let (_directory, state, routes) = fixture(disabled).await;
                configure_agent(&state, &routes).await;
                let profile: dbx_core::models::connection::TransportLayerConfig =
                    serde_json::from_value(serde_json::json!({
                        "type":"proxy","id":"shared","name":"Shared","host":"127.0.0.1","port":65000
                    }))
                    .unwrap();
                state.app.storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
                let mut layer = serde_json::to_value(&profile).unwrap();
                layer["profile_id"] = serde_json::json!("shared");
                layer["id"] = serde_json::json!("reference");
                state.app.configs.write().await.get_mut("conn").unwrap().transport_layers =
                    vec![serde_json::from_value(layer).unwrap()];
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                if orphan {
                    state.app.storage.save_tunnel_profiles(&[]).await.unwrap();
                }
                state.app.storage.set_secret("tunnel_profile.shared", "extra", "retained-secret").await.unwrap();
                let before = state.app.storage.load_tunnel_profiles_readonly().await.unwrap();
                let response =
                    routes.post("/tunnel-profiles/save", cookie, serde_json::json!({"profiles":before})).await;
                let retained = state.app.storage.get_secret("tunnel_profile.shared", "extra").await.unwrap();
                let unchanged = state.app.storage.load_tunnel_profiles_readonly().await.unwrap() == before;
                let closes = events(&state, "pl_debug_close");
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
                outcomes.push((
                    disabled,
                    cookie.is_some(),
                    orphan,
                    response.status(),
                    retained.is_some(),
                    unchanged,
                    closes,
                ));
            }
        }
        assert!(
            outcomes.iter().all(|(_, _, _, status, retained, unchanged, closes)| {
                *status == StatusCode::FORBIDDEN && *retained && *unchanged && *closes == 0
            }),
            "{outcomes:?}"
        );
    }

    #[tokio::test]
    async fn profile_save_reauthorizes_raw_only_changes_after_waiting_for_original_cleanup() {
        let (_directory, state, routes) = fixture(false).await;
        configure_agent(&state, &routes).await;
        let profiles = ["shared", "other"].map(|id| {
            serde_json::from_value::<dbx_core::models::connection::TransportLayerConfig>(serde_json::json!({
                "type":"proxy","id":id,"host":"127.0.0.1","port":65000
            }))
            .unwrap()
        });
        state.app.storage.save_tunnel_profiles(&profiles).await.unwrap();
        let original = state.app.configs.read().await["conn"].clone();
        for (id, profile) in ["conn", "other"].into_iter().zip(&profiles) {
            let mut config = original.clone();
            config.id = id.into();
            let mut layer = serde_json::to_value(profile).unwrap();
            layer["profile_id"] = serde_json::json!(profile.id());
            layer["id"] = serde_json::json!("reference");
            config.transport_layers = vec![serde_json::from_value(layer).unwrap()];
            state.app.configs.write().await.insert(id.into(), config);
        }
        state.app.session_credentials.set("second", "other", "second-secret");
        start_session(&state, &routes, "first").await;
        let second = start_session_at(&state, &routes, "second", "other").await;
        let driver = state.app.agent_manager.driver_dir("oracle");
        std::fs::write(driver.join("delay-close"), "ready").unwrap();
        let mut changed = serde_json::to_value(&profiles).unwrap();
        changed[0]["password"] = serde_json::json!("changed-secret");
        let address = routes.address;
        let save = tokio::spawn(async move {
            reqwest::Client::new()
                .post(format!("http://{address}/tunnel-profiles/save"))
                .header("cookie", "dbx_session=first")
                .json(&serde_json::json!({"profiles":changed}))
                .send()
                .await
                .unwrap()
        });
        wait_events(&state, "pl_debug_close", 1).await;
        state.app.storage.set_secret("tunnel_profile.other", "extra", "other-retained-secret").await.unwrap();
        std::fs::write(driver.join("close-gate"), "ready").unwrap();
        let response = save.await.unwrap();
        let saved = state.app.storage.load_tunnel_profiles_readonly().await.unwrap();
        let extra = state.app.storage.get_secret("tunnel_profile.other", "extra").await.unwrap();
        let status: Value = routes
            .post("/pl-debug/status", Some("dbx_session=second"), serde_json::json!({"reference":second}))
            .await
            .json()
            .await
            .unwrap();
        let closes = events(&state, "pl_debug_close");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(response.status(), StatusCode::FORBIDDEN);
        assert_eq!(saved, profiles);
        assert!(extra.is_some());
        assert_eq!(status["state"], "paused");
        assert_eq!(closes, 1);
    }

    #[tokio::test]
    async fn profile_save_replans_before_restoring_references_after_a_concurrent_target_change() {
        let (_directory, state, routes) = fixture(false).await;
        configure_agent(&state, &routes).await;
        let profiles = ["shared", "other"].map(|id| {
            serde_json::from_value::<dbx_core::models::connection::TransportLayerConfig>(serde_json::json!({
                "type":"proxy","id":id,"host":"127.0.0.1","port":65000,"password":"original-secret"
            }))
            .unwrap()
        });
        state.app.storage.save_tunnel_profiles(&profiles).await.unwrap();
        let mut layer = serde_json::to_value(&profiles[0]).unwrap();
        layer["id"] = serde_json::json!("reference");
        layer["profile_id"] = serde_json::json!("shared");
        state.app.configs.write().await.get_mut("conn").unwrap().transport_layers =
            vec![serde_json::from_value(layer).unwrap()];
        start_session(&state, &routes, "first").await;
        let driver = state.app.agent_manager.driver_dir("oracle");
        std::fs::write(driver.join("delay-close"), "ready").unwrap();
        let mut changed = serde_json::to_value(&profiles[0]).unwrap();
        changed["password"] = serde_json::json!("replacement-secret");
        let other = crate::credentials::redact_tunnel(profiles[1].clone());
        let address = routes.address;
        let save = tokio::spawn(async move {
            reqwest::Client::new()
                .post(format!("http://{address}/tunnel-profiles/save"))
                .header("cookie", "dbx_session=first")
                .json(&serde_json::json!({"profiles":[changed,other]}))
                .send()
                .await
                .unwrap()
        });
        wait_events(&state, "pl_debug_close", 1).await;
        let mut concurrent = serde_json::to_value(&profiles).unwrap();
        concurrent[1]["host"] = serde_json::json!("127.0.0.2");
        let concurrent: Vec<dbx_core::models::connection::TransportLayerConfig> =
            serde_json::from_value(concurrent).unwrap();
        state.app.storage.save_tunnel_profiles(&concurrent).await.unwrap();
        std::fs::write(driver.join("close-gate"), "ready").unwrap();
        let response = save.await.unwrap();
        let status = response.status();
        let error: Value = response.json().await.unwrap();
        let stored = state.app.storage.load_tunnel_profiles_readonly().await.unwrap();
        let closes = events(&state, "pl_debug_close");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(status, StatusCode::FORBIDDEN, "{error}");
        assert_eq!(stored, concurrent);
        assert_eq!(closes, 1);
    }

    #[tokio::test]
    async fn profile_save_preserves_unrelated_and_display_changes_but_cleans_up_its_owners_source() {
        let (_directory, state, routes) = fixture(false).await;
        configure_agent(&state, &routes).await;
        let profile: dbx_core::models::connection::TransportLayerConfig = serde_json::from_value(serde_json::json!({
            "type":"proxy","id":"shared","name":"Shared","enabled":true,"proxy_type":"socks5",
            "host":"127.0.0.1","port":65000,"username":"","password":"original-secret"
        }))
        .unwrap();
        let mut other = serde_json::to_value(&profile).unwrap();
        other["id"] = serde_json::json!("other");
        state
            .app
            .storage
            .save_tunnel_profiles(&[profile.clone(), serde_json::from_value(other.clone()).unwrap()])
            .await
            .unwrap();
        let mut reference = serde_json::to_value(&profile).unwrap();
        reference["id"] = serde_json::json!("reference");
        reference["profile_id"] = serde_json::json!("shared");
        state.app.configs.write().await.get_mut("conn").unwrap().transport_layers =
            vec![serde_json::from_value(reference).unwrap()];
        start_session(&state, &routes, "first").await;
        state.sessions.write().await.insert("second".into());
        let mut renamed = serde_json::to_value(&profile).unwrap();
        renamed["name"] = serde_json::json!("Renamed");
        renamed["enabled"] = serde_json::json!(false);
        other["password"] = serde_json::json!("other-changed");
        let allowed = routes
            .post("/tunnel-profiles/save", Some("dbx_session=second"), serde_json::json!({"profiles":[renamed,other]}))
            .await;
        let allowed_status = allowed.status();
        let closes_after_unrelated = events(&state, "pl_debug_close");
        let saved = state.app.storage.load_tunnel_profiles_readonly().await.unwrap();
        let mut cleared = saved.clone();
        cleared.iter_mut().find(|profile| profile.id() == "shared").unwrap().scrub_secrets();
        let changed = routes
            .post("/tunnel-profiles/save", Some("dbx_session=first"), serde_json::json!({"profiles":cleared}))
            .await;
        let changed_status = changed.status();
        let closes_after_own_change = events(&state, "pl_debug_close");
        let final_profiles = state.app.storage.load_tunnel_profiles_readonly().await.unwrap();
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(allowed_status, StatusCode::OK);
        assert_eq!(closes_after_unrelated, 0);
        assert_eq!(changed_status, StatusCode::OK);
        assert_eq!(closes_after_own_change, 1);
        assert_eq!(final_profiles, cleared);
    }

    #[tokio::test]
    async fn final_proxy_port_rejects_foreign_configuration_changes_before_any_effect() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            start_session(&state, &routes, "first").await;
            state.sessions.write().await.insert("second".into());
            let original = state.app.configs.read().await.get("conn").unwrap().clone();
            let mut replacement = serde_json::to_value(&original).unwrap();
            replacement["host"] = serde_json::json!("127.0.0.2");
            replacement["transport_layers"] = serde_json::json!([{
                "type":"proxy","id":"proxy","name":"Proxy","enabled":true,"proxy_type":"socks5",
                "host":"127.0.0.1","port":65000,"username":"","password":"","profile_id":""
            }]);
            let response =
                routes.post("/connection/final-proxy-port", cookie, serde_json::json!({"config":replacement})).await;
            let unchanged = state.app.configs.read().await.get("conn") == Some(&original);
            let closes = events(&state, "pl_debug_close");
            let proxy_started = state.app.proxy_tunnels.local_port("conn:transport:0").await.is_some();
            let credentials = state.app.session_credentials.get("", "conn");
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            outcomes.push((
                disabled,
                cookie.is_some(),
                response.status(),
                unchanged,
                closes,
                proxy_started,
                credentials,
            ));
        }
        assert!(
            outcomes.iter().all(|(_, _, status, unchanged, closes, proxy_started, credentials)| {
                *status == StatusCode::FORBIDDEN
                    && *unchanged
                    && *closes == 0
                    && !*proxy_started
                    && credentials.as_deref() == Some("anonymous-secret")
            }),
            "{outcomes:?}"
        );
    }

    #[tokio::test]
    async fn final_proxy_port_reuses_an_unchanged_connection_without_closing_another_owners_debugger() {
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            state.sessions.write().await.insert("first".into());
            state.sessions.write().await.insert("second".into());
            let mut config = serde_json::to_value(state.app.configs.read().await.get("conn").unwrap()).unwrap();
            config["transport_layers"] = serde_json::json!([{
                "type":"proxy","id":"proxy","name":"Proxy","enabled":true,"proxy_type":"socks5",
                "host":"127.0.0.1","port":65000,"username":"","password":"","profile_id":""
            }]);
            let initial = routes
                .post("/connection/final-proxy-port", Some("dbx_session=first"), serde_json::json!({"config":config}))
                .await;
            assert_eq!(initial.status(), StatusCode::OK);
            let port: u16 = initial.json().await.unwrap();
            start_session(&state, &routes, "first").await;
            let response =
                routes.post("/connection/final-proxy-port", cookie, serde_json::json!({"config":config})).await;
            let status = response.status();
            let reused: Value = response.json().await.unwrap();
            let closes = events(&state, "pl_debug_close");
            let still_listening = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.is_ok();
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            assert_eq!(status, StatusCode::OK, "{reused}");
            assert_eq!(reused, port);
            assert_eq!(closes, 0);
            assert!(still_listening);
        }
    }

    #[tokio::test]
    async fn final_proxy_port_owner_can_change_its_connection_after_original_debug_cleanup() {
        for disabled in [false, true] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            start_session(&state, &routes, "first").await;
            let mut config = serde_json::to_value(state.app.configs.read().await.get("conn").unwrap()).unwrap();
            config["transport_layers"] = serde_json::json!([{
                "type":"proxy","id":"proxy","name":"Proxy","enabled":true,"proxy_type":"socks5",
                "host":"127.0.0.1","port":65000,"username":"","password":"","profile_id":""
            }]);
            let response = routes
                .post("/connection/final-proxy-port", Some("dbx_session=first"), serde_json::json!({"config":config}))
                .await;
            let status = response.status();
            let port: Value = response.json().await.unwrap();
            let closes = events(&state, "pl_debug_close");
            let configured = state.app.configs.read().await.get("conn").unwrap().has_effective_transport_layers();
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            assert_eq!(status, StatusCode::OK, "{port}");
            assert!(port.as_u64().is_some_and(|port| port > 0));
            assert_eq!(closes, 1);
            assert!(configured);
        }
    }

    #[tokio::test]
    async fn mcp_creation_cannot_take_another_browsers_runtime_only_debug_connection() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            for path in ["/connection/mcp/add", "/connection/mcp/duplicate"] {
                let (_directory, state, routes) = fixture(disabled).await;
                configure_agent(&state, &routes).await;
                let original = state.app.configs.read().await.get("conn").unwrap().clone();
                let mut source = original.clone();
                source.id = "source".into();
                source.name = "Source fixture".into();
                state.app.storage.save_connections(&[source]).await.unwrap();
                state
                    .app
                    .storage
                    .save_mcp_global_policy(&dbx_core::storage::McpGlobalPolicy {
                        read_only: false,
                        allowed_connection_ids: None,
                        ..Default::default()
                    })
                    .await
                    .unwrap();
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                let before = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
                let body = if path == "/connection/mcp/add" {
                    let mut replacement = original.clone();
                    replacement.host = "127.0.0.2".into();
                    serde_json::json!({"config":replacement})
                } else {
                    serde_json::json!({"sourceId":"source","copyId":"conn","copyName":"Copied debug fixture"})
                };
                let response = routes.post(path, cookie, body).await;
                let after = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
                let unchanged_runtime = state.app.configs.read().await.get("conn") == Some(&original);
                outcomes.push((
                    path,
                    disabled,
                    cookie.is_some(),
                    response.status(),
                    before == after,
                    unchanged_runtime,
                    events(&state, "pl_debug_close"),
                ));
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
            }
        }
        assert!(
            outcomes.iter().all(|(_, _, _, status, stored, runtime, closes)| *status == StatusCode::FORBIDDEN
                && *stored
                && *runtime
                && *closes == 0),
            "{outcomes:?}"
        );
    }

    #[tokio::test]
    async fn mcp_creation_preserves_own_cleanup_unrelated_targets_and_transaction_rejections() {
        let mut outcomes = Vec::new();
        for path in ["/connection/mcp/add", "/connection/mcp/duplicate"] {
            for scenario in ["own", "unrelated", "read-only"] {
                let (_directory, state, routes) = fixture(false).await;
                configure_agent(&state, &routes).await;
                let original = state.app.configs.read().await.get("conn").unwrap().clone();
                let mut source = original.clone();
                source.id = "source".into();
                source.name = "Source fixture".into();
                state.app.storage.save_connections(&[source]).await.unwrap();
                state
                    .app
                    .storage
                    .save_mcp_global_policy(&dbx_core::storage::McpGlobalPolicy {
                        read_only: scenario == "read-only",
                        allowed_connection_ids: None,
                        ..Default::default()
                    })
                    .await
                    .unwrap();
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                let target = if scenario == "unrelated" { "unrelated" } else { "conn" };
                let body = if path == "/connection/mcp/add" {
                    let mut replacement = original.clone();
                    replacement.id = target.into();
                    replacement.name = "New fixture".into();
                    replacement.host = "127.0.0.2".into();
                    serde_json::json!({"config":replacement})
                } else {
                    serde_json::json!({"sourceId":"source","copyId":target,"copyName":"Copied fixture"})
                };
                let cookie = if scenario == "unrelated" { "dbx_session=second" } else { "dbx_session=first" };
                let response = routes.post(path, Some(cookie), body).await;
                let status = response.status();
                let stored = state.app.storage.load_connections().await.unwrap();
                let runtime = state.app.configs.read().await;
                let valid = if scenario == "read-only" {
                    let error: Value = response.json().await.unwrap();
                    !status.is_success()
                        && error.to_string().contains("MCP_READ_ONLY:")
                        && stored.len() == 1
                        && runtime.get("conn") == Some(&original)
                        && events(&state, "pl_debug_close") == 0
                } else {
                    status == StatusCode::OK
                        && stored.iter().any(|config| config.id == target)
                        && runtime.contains_key(target)
                        && events(&state, "pl_debug_close") == usize::from(scenario == "own")
                        && (scenario == "own" || runtime.get("conn") == Some(&original))
                };
                drop(runtime);
                outcomes.push((path, scenario, status, valid));
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
            }
        }
        assert!(outcomes.iter().all(|(_, _, _, valid)| *valid), "{outcomes:?}");
    }

    #[tokio::test]
    async fn write_unlock_mutations_only_protect_debuggers_sharing_the_actual_credential_scope() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            for path in ["/connection/write-unlock", "/connection/write-unlock/lock"] {
                let (_directory, state, routes) = fixture(disabled).await;
                configure_agent(&state, &routes).await;
                state.app.configs.write().await.get_mut("conn").unwrap().read_only = true;
                state.sessions.write().await.insert("first".into());
                let first_cookie = Some("dbx_session=first");
                let unlocked = routes
                    .post(
                        "/connection/write-unlock",
                        first_cookie,
                        serde_json::json!({"connectionId":"conn","durationSecs":60}),
                    )
                    .await;
                assert_eq!(unlocked.status(), StatusCode::OK);
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                let response =
                    routes.post(path, cookie, serde_json::json!({"connectionId":"conn","durationSecs":300})).await;
                let remaining: Value = routes
                    .post("/connection/write-unlock/state", first_cookie, serde_json::json!({"connectionId":"conn"}))
                    .await
                    .json()
                    .await
                    .unwrap();
                let closes = events(&state, "pl_debug_close");
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
                outcomes.push((
                    path,
                    disabled,
                    cookie.is_some(),
                    response.status(),
                    remaining["remainingMs"].as_u64().unwrap(),
                    closes,
                ));
            }
        }
        assert!(
            outcomes.iter().all(|(_, disabled, _, status, remaining, closes)| {
                *status == if *disabled { StatusCode::FORBIDDEN } else { StatusCode::OK }
                    && *remaining > 0
                    && *remaining <= 60_000
                    && *closes == 0
            }),
            "{outcomes:?}"
        );
    }

    #[tokio::test]
    async fn write_unlock_owner_can_change_own_window_without_closing_the_debugger() {
        for disabled in [false, true] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            start_session(&state, &routes, "first").await;
            let cookie = Some("dbx_session=first");
            let unlocked = routes
                .post("/connection/write-unlock", cookie, serde_json::json!({"connectionId":"conn","durationSecs":300}))
                .await;
            assert_eq!(unlocked.status(), StatusCode::OK);
            let locked =
                routes.post("/connection/write-unlock/lock", cookie, serde_json::json!({"connectionId":"conn"})).await;
            let remaining: Value = routes
                .post("/connection/write-unlock/state", cookie, serde_json::json!({"connectionId":"conn"}))
                .await
                .json()
                .await
                .unwrap();
            let closes = events(&state, "pl_debug_close");
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            assert_eq!(locked.status(), StatusCode::OK);
            assert_eq!(remaining["remainingMs"], 0);
            assert_eq!(closes, 0);
        }
    }

    #[tokio::test]
    async fn configuration_save_keeps_password_disabled_browser_credentials_in_the_original_empty_scope() {
        let (_directory, state, routes) = fixture(true).await;
        configure_agent(&state, &routes).await;
        state.sessions.write().await.insert("first".into());
        let mut config = state.app.configs.read().await.get("conn").unwrap().clone();
        config.password = "first-secret".into();
        let saved = routes
            .post(
                "/connection/save",
                Some("dbx_session=first"),
                serde_json::json!({"configs":[config],"removedIds":[]}),
            )
            .await;
        let original_scope_updated = state.app.session_credentials.get("", "conn").as_deref() == Some("first-secret");
        start_session(&state, &routes, "first").await;
        let opened_with_new_credential = events(&state, "credential_first");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(saved.status(), StatusCode::OK);
        assert!(original_scope_updated, "the debug browser cookie changed the existing anonymous credential scope");
        assert_eq!(opened_with_new_credential, 1);
    }

    #[tokio::test]
    async fn configuration_save_reauthorizes_new_affected_connections_after_debug_cleanup_before_writing() {
        let (_directory, state, routes) = fixture(true).await;
        configure_agent(&state, &routes).await;
        let original = state.app.configs.read().await.get("conn").unwrap().clone().canonicalized();
        let mut other = original.clone();
        other.id = "other".into();
        other.name = "Other debug fixture".into();
        state.app.configs.write().await.insert("conn".into(), original.clone());
        state.app.configs.write().await.insert("other".into(), other.clone());
        state.app.session_credentials.set("", "other", "anonymous-secret");
        state.app.storage.save_connections(&[original.clone(), other.clone()]).await.unwrap();
        let first = start_session(&state, &routes, "first").await;
        let second = start_session_at(&state, &routes, "second", "other").await;
        let before = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
        let driver = state.app.agent_manager.driver_dir("oracle");
        std::fs::write(driver.join("delay-close"), "ready").unwrap();
        let mut changed = original.clone();
        changed.host = "127.0.0.2".into();
        let address = routes.address;
        let save = tokio::spawn(async move {
            reqwest::Client::new()
                .post(format!("http://{address}/connection/save"))
                .header("cookie", "dbx_session=first")
                .json(&serde_json::json!({"configs":[changed,other],"removedIds":[]}))
                .send()
                .await
                .unwrap()
        });
        wait_events(&state, "pl_debug_close", 1).await;
        state.app.configs.write().await.get_mut("other").unwrap().host = "127.0.0.3".into();
        std::fs::write(driver.join("close-gate"), "ready").unwrap();
        let response = tokio::time::timeout(std::time::Duration::from_secs(10), save).await.unwrap().unwrap();
        let after = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
        let second_status: Value = routes
            .post("/pl-debug/status", Some("dbx_session=second"), serde_json::json!({"reference":second}))
            .await
            .json()
            .await
            .unwrap();
        let first_status: Value = routes
            .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":first}))
            .await
            .json()
            .await
            .unwrap();
        let closes = events(&state, "pl_debug_close");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(response.status(), StatusCode::FORBIDDEN);
        assert_eq!(before, after);
        assert_eq!(second_status["state"], "paused");
        assert_eq!(first_status["state"], "ended");
        assert_eq!(closes, 1);
    }

    #[tokio::test]
    async fn configuration_load_rereads_persisted_connections_after_cleanup_without_rolling_back_another_save() {
        let (_directory, state, routes) = fixture(true).await;
        configure_agent(&state, &routes).await;
        let original = state.app.configs.read().await.get("conn").unwrap().clone().canonicalized();
        state.app.configs.write().await.insert("conn".into(), original.clone());
        let mut persisted = original.clone();
        persisted.host = "127.0.0.2".into();
        state.app.storage.save_connections(&[persisted]).await.unwrap();
        start_session(&state, &routes, "first").await;
        state.sessions.write().await.insert("second".into());
        let driver = state.app.agent_manager.driver_dir("oracle");
        std::fs::write(driver.join("delay-close"), "ready").unwrap();
        let address = routes.address;
        let load = tokio::spawn(async move {
            reqwest::Client::new()
                .get(format!("http://{address}/connection/list"))
                .header("cookie", "dbx_session=first")
                .send()
                .await
                .unwrap()
        });
        wait_events(&state, "pl_debug_close", 1).await;
        let mut other = original.clone();
        other.id = "other".into();
        let saved = tokio::time::timeout(
            std::time::Duration::from_secs(5),
            routes.post(
                "/connection/save",
                Some("dbx_session=second"),
                serde_json::json!({"configs":[other],"removedIds":[]}),
            ),
        )
        .await;
        std::fs::write(driver.join("close-gate"), "ready").unwrap();
        let loaded = tokio::time::timeout(std::time::Duration::from_secs(10), load).await.unwrap().unwrap();
        let status = loaded.status();
        let configs: Value = loaded.json().await.unwrap();
        let retained = state.app.configs.read().await.contains_key("other");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(saved.unwrap().status(), StatusCode::OK, "saving an unrelated delta waited on another debugger");
        assert_eq!(status, StatusCode::OK);
        assert!(retained);
        assert!(configs.as_array().unwrap().iter().any(|config| config["id"] == "other"));
    }

    #[tokio::test]
    async fn configuration_load_and_save_with_no_effect_on_a_debugger_do_not_require_its_owner() {
        let (_directory, state, routes) = fixture(true).await;
        configure_agent(&state, &routes).await;
        let original = state.app.configs.read().await.get("conn").unwrap().clone().canonicalized();
        state.app.configs.write().await.insert("conn".into(), original.clone());
        state.app.storage.save_connections(std::slice::from_ref(&original)).await.unwrap();
        let reference = start_session(&state, &routes, "first").await;
        state.sessions.write().await.insert("second".into());
        let saved = routes
            .post(
                "/connection/save",
                Some("dbx_session=second"),
                serde_json::json!({"configs":[original],"removedIds":[]}),
            )
            .await;
        let loaded =
            reqwest::Client::new().get(format!("http://{}/connection/list", routes.address)).send().await.unwrap();
        let status: Value = routes
            .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":reference}))
            .await
            .json()
            .await
            .unwrap();
        let closes = events(&state, "pl_debug_close");
        state.app.shutdown(std::time::Duration::from_secs(1)).await;
        assert_eq!(saved.status(), StatusCode::OK);
        assert_eq!(loaded.status(), StatusCode::OK);
        assert_eq!(status["state"], "paused");
        assert_eq!(closes, 0);
    }

    #[tokio::test]
    async fn ordinary_configuration_changes_cannot_replace_another_browsers_debug_connection() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            for path in ["/connection/connect", "/connection/save", "/connection/list", "/connection/mcp/remove"] {
                let (_directory, state, routes) = fixture(disabled).await;
                configure_agent(&state, &routes).await;
                let original = state.app.configs.read().await.get("conn").unwrap().clone();
                let mut changed = original.clone();
                changed.host = "127.0.0.2".into();
                let stored = if path == "/connection/list" { changed.clone() } else { original.clone() };
                state.app.storage.save_connections(&[stored]).await.unwrap();
                start_session(&state, &routes, "first").await;
                state.sessions.write().await.insert("second".into());
                let before = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
                let response = if path == "/connection/list" {
                    let mut request = reqwest::Client::new().get(format!("http://{}{path}", routes.address));
                    if let Some(cookie) = cookie {
                        request = request.header("cookie", cookie);
                    }
                    request.send().await.unwrap()
                } else {
                    let body = match path {
                        "/connection/connect" => serde_json::json!({"config":changed,"clientAttempt":42}),
                        "/connection/save" => {
                            let mut added = original.clone();
                            added.id = "unrelated".into();
                            serde_json::json!({"configs":[added,changed],"removedIds":[]})
                        }
                        _ => serde_json::json!({"connectionId":"conn"}),
                    };
                    routes.post(path, cookie, body).await
                };
                let after = serde_json::to_value(state.app.storage.load_connections().await.unwrap()).unwrap();
                let unchanged_runtime = state.app.configs.read().await.get("conn").is_some_and(|config| {
                    serde_json::to_value(config).unwrap() == serde_json::to_value(&original).unwrap()
                });
                outcomes.push((
                    path,
                    disabled,
                    cookie.is_some(),
                    response.status(),
                    before == after,
                    unchanged_runtime,
                    events(&state, "pl_debug_close"),
                ));
                state.app.shutdown(std::time::Duration::from_secs(1)).await;
            }
        }
        for (path, disabled, cookie, status, storage_unchanged, runtime_unchanged, closes) in outcomes {
            assert_eq!(status, StatusCode::FORBIDDEN, "{path} disabled={disabled} cookie={cookie}; storage unchanged={storage_unchanged}; runtime unchanged={runtime_unchanged}; close={closes}");
            assert!(storage_unchanged && runtime_unchanged);
            assert_eq!(closes, 0);
        }
    }

    #[tokio::test]
    async fn ordinary_disconnect_cannot_close_another_browser_debugger() {
        let mut outcomes = Vec::new();
        for (disabled, cookie) in
            [(false, Some("dbx_session=second")), (true, Some("dbx_session=second")), (true, None)]
        {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            let reference = start_session(&state, &routes, "first").await;
            state.sessions.write().await.insert("second".into());
            let response =
                routes.post("/connection/disconnect", cookie, serde_json::json!({"connectionId":"conn"})).await;
            let status: Value = routes
                .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":reference}))
                .await
                .json()
                .await
                .unwrap();
            outcomes.push((
                disabled,
                cookie.is_some(),
                response.status(),
                events(&state, "pl_debug_close"),
                status["state"].clone(),
            ));
            if disabled {
                assert_eq!(
                    routes
                        .post("/connection/disconnect", None, serde_json::json!({"connectionId":"unrelated"}))
                        .await
                        .status(),
                    StatusCode::OK,
                );
            }
            let own = routes
                .post("/connection/disconnect", Some("dbx_session=first"), serde_json::json!({"connectionId":"conn"}))
                .await;
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            assert_eq!(own.status(), StatusCode::OK);
            assert_eq!(events(&state, "pl_debug_close"), 1);
        }
        for (disabled, cookie, status, closes, debug_state) in outcomes {
            assert_eq!(
                status,
                StatusCode::FORBIDDEN,
                "disconnect disabled={disabled} cookie={cookie}; close events={closes}; debugger={debug_state}"
            );
            assert_eq!(closes, 0);
            assert_eq!(debug_state, "paused");
        }
    }

    #[tokio::test]
    async fn ordinary_runtime_operations_cannot_stop_another_browser_debugger() {
        let mut outcomes = Vec::new();
        for (path, body) in [
            ("/agents/runtime/stop", serde_json::json!({"runtimeId":"agent-runtime:oracle:0"})),
            ("/agents/runtime/restart", serde_json::json!({"runtimeId":"agent-runtime:oracle:0"})),
            ("/agents/java-runtime", serde_json::json!({"config":{"mode":"managed"}})),
        ] {
            let (_directory, state, routes) = fixture(true).await;
            configure_agent(&state, &routes).await;
            start_session(&state, &routes, "first").await;
            state.sessions.write().await.insert("second".into());
            let before = state.app.agent_manager.connection_runtimes.lock().await.len();
            assert_eq!(before, 1);
            let response = routes.post(path, Some("dbx_session=second"), body.clone()).await;
            outcomes.push((
                path,
                response.status(),
                state.app.agent_manager.connection_runtimes.lock().await.len(),
                events(&state, "pl_debug_close"),
            ));
            assert_eq!(routes.post(path, None, body.clone()).await.status(), StatusCode::FORBIDDEN);
            assert_eq!(state.app.agent_manager.connection_runtimes.lock().await.len(), 1);
            assert_eq!(
                routes
                    .post(
                        "/agents/runtime/stop",
                        Some("dbx_session=second"),
                        serde_json::json!({"runtimeId":"agent-runtime:oceanbase-oracle:0"})
                    )
                    .await
                    .status(),
                StatusCode::OK,
            );
            assert_eq!(state.app.agent_manager.connection_runtimes.lock().await.len(), 1);
            let own = routes.post(path, Some("dbx_session=first"), body).await;
            state.app.shutdown(std::time::Duration::from_secs(1)).await;
            assert_eq!(own.status(), StatusCode::OK);
            assert_eq!(events(&state, "pl_debug_close"), 1);
        }
        for (path, status, runtimes, closes) in outcomes {
            assert_eq!(status, StatusCode::FORBIDDEN, "{path} retained runtimes={runtimes}; close events={closes}");
            assert_eq!(runtimes, 1);
            assert_eq!(closes, 0);
        }
    }

    #[tokio::test]
    async fn browser_ownership_refresh_and_logout_use_the_original_core_session() {
        for disabled in [true, false] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            let reference = start_session(&state, &routes, "first").await;
            let other = start_session(&state, &routes, "second").await;
            assert_eq!(events(&state, "credential_wrong"), 0);
            assert_eq!(events(&state, "credential_default"), if disabled { 2 } else { 0 });
            assert_eq!(events(&state, "credential_first"), if disabled { 0 } else { 1 });
            assert_eq!(events(&state, "credential_second"), if disabled { 0 } else { 1 });
            let bootstrap: Value = routes
                .post("/pl-debug/bootstrap", Some("dbx_session=first"), serde_json::json!({}))
                .await
                .json()
                .await
                .unwrap();
            let list: Value = routes
                .post(
                    "/pl-debug/list",
                    Some("dbx_session=first"),
                    serde_json::json!({
                        "serverEpoch":bootstrap["serverEpoch"],"connectionId":"conn"
                    }),
                )
                .await
                .json()
                .await
                .unwrap();
            assert_eq!(list.as_array().unwrap().len(), 1);
            assert_eq!(list[0]["sessionId"], reference["sessionId"]);
            assert_eq!(list[0]["clientSessionId"], reference["clientSessionId"]);
            assert_eq!(list[0]["startOperationId"], "start-first");
            assert_eq!(list[0]["recovery"]["version"], 1);
            assert_eq!(list[0]["recovery"]["operations"], serde_json::json!([]));
            // Discovery restores the original client identity; it does not authorize
            // a new client to control that session using only its public session ID.
            let mut wrong_client = reference.clone();
            wrong_client["clientSessionId"] = serde_json::json!("replacement-editor");
            let denied = routes
                .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":wrong_client}))
                .await;
            assert!(!denied.status().is_success(), "same-owner replacement client was accepted");
            let recovered: Value = routes
                .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":reference}))
                .await
                .json()
                .await
                .unwrap();
            assert_eq!(recovered["sessionId"], reference["sessionId"]);
            assert_eq!(recovered["state"], "paused");
            assert_eq!(events(&state, "pl_debug_start"), 2);
            for (path, body) in [
                ("status", serde_json::json!({"reference":reference,"refresh":true})),
                ("heartbeat", reference.clone()),
                ("operation", serde_json::json!({"reference":reference,"operationId":"start-first"})),
                (
                    "read",
                    serde_json::json!({"serverEpoch":reference["serverEpoch"],"sessionId":reference["sessionId"],
                    "connectionId":"conn","clientSessionId":"editor","generation":1,"stopRevision":1,"kind":"log"}),
                ),
                (
                    "operate",
                    serde_json::json!({"serverEpoch":reference["serverEpoch"],"sessionId":reference["sessionId"],
                    "connectionId":"conn","clientSessionId":"editor","generation":1,"expectedRevision":2,"operationId":"steal-close","action":"close"}),
                ),
            ] {
                let response = routes.post(&format!("/pl-debug/{path}"), Some("dbx_session=second"), body).await;
                assert!(!response.status().is_success(), "cross-owner {path} was accepted");
            }
            assert_eq!(events(&state, "pl_debug_close"), 0);
            assert_eq!(
                routes.post("/auth/logout", Some("dbx_session=first"), serde_json::json!({})).await.status(),
                StatusCode::OK
            );
            wait_events(&state, "shutdown", 1).await;
            assert_eq!(events(&state, "pl_debug_close"), 1);
            let denied = routes.post("/pl-debug/heartbeat", Some("dbx_session=first"), reference).await;
            assert!(!denied.status().is_success());
            let status: Value = routes
                .post("/pl-debug/status", Some("dbx_session=second"), serde_json::json!({"reference":other}))
                .await
                .json()
                .await
                .unwrap();
            assert_eq!(status["state"], "paused");
            routes.post("/auth/logout", Some("dbx_session=second"), serde_json::json!({})).await;
            wait_events(&state, "shutdown", 2).await;
        }
    }

    #[tokio::test]
    async fn password_rotation_cleans_revoked_debuggers_but_keeps_the_current_owner() {
        use argon2::password_hash::{rand_core::OsRng, SaltString};
        use argon2::{Argon2, PasswordHasher};
        let (_directory, state, routes) = fixture(false).await;
        configure_agent(&state, &routes).await;
        *state.password_hash.write().await =
            Some(Argon2::default().hash_password(b"old", &SaltString::generate(&mut OsRng)).unwrap().to_string());
        let reference = start_session(&state, &routes, "first").await;
        start_session(&state, &routes, "second").await;
        let changed = routes
            .post(
                "/auth/change-password",
                Some("dbx_session=first"),
                serde_json::json!({"old_password":"old","new_password":"new"}),
            )
            .await;
        assert_eq!(changed.status(), StatusCode::OK);
        wait_events(&state, "shutdown", 1).await;
        assert_eq!(events(&state, "pl_debug_close"), 1);
        assert!(state.sessions.read().await.contains("first"));
        assert!(!state.sessions.read().await.contains("second"));
        let status: Value = routes
            .post("/pl-debug/status", Some("dbx_session=first"), serde_json::json!({"reference":reference}))
            .await
            .json()
            .await
            .unwrap();
        assert_eq!(status["state"], "paused");
        routes.post("/auth/logout", Some("dbx_session=first"), serde_json::json!({})).await;
        wait_events(&state, "shutdown", 2).await;
    }

    fn registered_inspection_body() -> Value {
        json!({
            "connectionId":"conn","database":"APP","clientSessionId":"typed-preview",
            "target":{"schema":"APP","objectType":"PROCEDURE","objectName":"P","metadataPreparation":"type_only"}
        })
    }

    async fn compilation_body(routes: &TestServer, owner: &str) -> Value {
        let cookie = format!("dbx_session={owner}");
        let bootstrap: Value = routes.post("/pl-debug/bootstrap", Some(&cookie), json!({})).await.json().await.unwrap();
        let mut inspection = registered_inspection_body();
        inspection["target"]["metadataPreparation"] = json!("debug_compile");
        let response = routes.post("/pl-debug/inspect", Some(&cookie), inspection.clone()).await;
        assert_eq!(response.status(), StatusCode::OK);
        let preview: Value = response.json().await.unwrap();
        json!({"serverEpoch":bootstrap["serverEpoch"],"operationId":"compile-original","connectionId":"conn",
            "database":"APP","clientSessionId":"compile-client","target":inspection["target"],
            "preview":preview["compilePreview"],"expectedConnectionRevision":preview["connectionRevision"],
            "confirmed":true,"productionConfirmed":false})
    }

    fn compile_reference(body: &Value) -> Value {
        json!({"serverEpoch":body["serverEpoch"],"operationId":body["operationId"],
            "connectionId":body["connectionId"],"clientSessionId":body["clientSessionId"]})
    }

    #[tokio::test]
    async fn compilation_http_preserves_cookie_credentials_original_receipt_and_client_ownership() {
        for disabled in [true, false] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            state.sessions.write().await.extend(["first".into(), "second".into()]);
            let body = compilation_body(&routes, "first").await;
            let accepted = routes.post("/pl-debug/compile", Some("dbx_session=first"), body.clone()).await;
            assert_eq!(accepted.status(), StatusCode::OK);
            let reference = compile_reference(&body);
            let result = tokio::time::timeout(std::time::Duration::from_secs(10), async {
                loop {
                    let response =
                        routes.post("/pl-debug/compile-status", Some("dbx_session=first"), reference.clone()).await;
                    assert_eq!(response.status(), StatusCode::OK);
                    let value: Value = response.json().await.unwrap();
                    if value["finished"] == true {
                        break value;
                    }
                    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
                }
            })
            .await
            .unwrap();
            assert_eq!(result["ddlState"], "executed");
            assert_eq!(result["releaseState"], "released");
            assert_eq!(result["result"]["readback"]["status"], "INVALID");
            let duplicate: Value =
                routes.post("/pl-debug/compile", Some("dbx_session=first"), body.clone()).await.json().await.unwrap();
            assert_eq!(duplicate, result);
            let denied = routes.post("/pl-debug/compile-status", Some("dbx_session=second"), reference.clone()).await;
            assert!(!denied.status().is_success());
            let mut wrong_client = reference.clone();
            wrong_client["clientSessionId"] = json!("another-client");
            assert!(!routes
                .post("/pl-debug/compile-status", Some("dbx_session=first"), wrong_client)
                .await
                .status()
                .is_success());
            assert_eq!(
                routes.post("/pl-debug/compile", Some("dbx_session=untrusted"), body.clone()).await.status(),
                if disabled { StatusCode::FORBIDDEN } else { StatusCode::UNAUTHORIZED }
            );
            let mut changed = body;
            changed["preview"]["sql"] = json!("different SQL");
            assert!(!routes.post("/pl-debug/compile", Some("dbx_session=first"), changed).await.status().is_success());
            assert_eq!(events(&state, "pl_debug_compile"), 1);
            assert_eq!(events(&state, "open_session"), 2);
            assert_eq!(events(&state, "credential_wrong"), 0);
            assert_eq!(events(&state, "credential_default"), if disabled { 2 } else { 0 });
            assert_eq!(events(&state, "credential_first"), if disabled { 0 } else { 2 });
        }
    }

    #[tokio::test]
    async fn compilation_http_rechecks_logout_after_async_preparation_before_registration() {
        for disabled in [true, false] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            state.sessions.write().await.insert("first".into());
            let body = compilation_body(&routes, "first").await;
            let mut headers = HeaderMap::new();
            headers.insert("cookie", "dbx_session=first".parse().unwrap());
            let owner = access(&state, &headers).await.unwrap();
            let admission =
                pl_debug::pl_debug_prepare_compile_core(&state.app, &owner, serde_json::from_value(body).unwrap())
                    .await
                    .unwrap();
            assert_eq!(
                routes.post("/auth/logout", Some("dbx_session=first"), json!({})).await.status(),
                StatusCode::OK
            );
            let denied = submit_prepared_compilation(&state, &headers, admission).await.unwrap_err();
            assert_eq!(denied.into_response().status(), StatusCode::FORBIDDEN);
            assert_eq!(events(&state, "pl_debug_compile"), 0);
            assert_eq!(events(&state, "open_session"), 1);
        }
    }

    #[tokio::test]
    async fn compilation_http_readonly_rejection_is_authoritative_not_started() {
        let (_directory, state, routes) = fixture(true).await;
        configure_agent(&state, &routes).await;
        state.sessions.write().await.insert("first".into());
        let body = compilation_body(&routes, "first").await;
        state.app.configs.write().await.get_mut("conn").unwrap().read_only = true;
        let response = routes.post("/pl-debug/compile", Some("dbx_session=first"), body).await;
        assert!(!response.status().is_success());
        let error: Value = response.json().await.unwrap();
        assert_eq!(error["operationOutcome"], "not_started");
        assert_eq!(events(&state, "pl_debug_compile"), 0);
        assert_eq!(events(&state, "open_session"), 1);
    }

    #[tokio::test]
    async fn registered_inspection_http_uses_the_existing_cookie_and_credential_scopes() {
        for disabled in [true, false] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            state.sessions.write().await.insert("first".into());
            let bootstrap: Value =
                routes.post("/pl-debug/bootstrap", Some("dbx_session=first"), json!({})).await.json().await.unwrap();
            let response =
                routes.post("/pl-debug/inspect", Some("dbx_session=first"), registered_inspection_body()).await;
            assert_eq!(response.status(), StatusCode::OK);
            let result: Value = response.json().await.unwrap();
            assert_eq!(result["targetPreview"]["state"], "available");
            assert!(result["connectionRevision"].is_string());
            assert_eq!(events(&state, "credential_wrong"), 0);
            assert_eq!(events(&state, "credential_default"), usize::from(disabled));
            assert_eq!(events(&state, "credential_first"), usize::from(!disabled));
            assert_eq!(events(&state, "open_session"), 1);
            assert_eq!(events(&state, "pl_debug_inspect"), 1);
            assert_eq!(events(&state, "close_session"), 1);
            assert_eq!(events(&state, "shutdown"), 1);
            assert_eq!(events(&state, "pl_debug_start"), 0);
            assert!(state.app.agent_manager.connection_runtimes.lock().await.is_empty());
            let list: Value = routes
                .post(
                    "/pl-debug/list",
                    Some("dbx_session=first"),
                    json!({"serverEpoch":bootstrap["serverEpoch"],"connectionId":"conn"}),
                )
                .await
                .json()
                .await
                .unwrap();
            assert_eq!(list, json!([]));
            let denied =
                routes.post("/pl-debug/inspect", Some("dbx_session=untrusted"), registered_inspection_body()).await;
            assert!(!denied.status().is_success());
            assert_eq!(events(&state, "pl_debug_inspect"), 1);
        }
    }

    #[tokio::test]
    async fn registered_inspection_logout_revokes_inflight_preview_without_closing_another_owner() {
        for disabled in [true, false] {
            let (_directory, state, routes) = fixture(disabled).await;
            configure_agent(&state, &routes).await;
            let second = start_session(&state, &routes, "second").await;
            state.sessions.write().await.insert("first".into());
            let driver = state.app.agent_manager.driver_dir("oracle");
            std::fs::write(driver.join("delay-inspect"), b"1").unwrap();
            let address = routes.address;
            let pending = tokio::spawn(async move {
                reqwest::Client::new()
                    .post(format!("http://{address}/pl-debug/inspect"))
                    .header("cookie", "dbx_session=first")
                    .json(&registered_inspection_body())
                    .send()
                    .await
                    .unwrap()
            });
            wait_events(&state, "pl_debug_inspect", 1).await;
            assert_eq!(
                routes.post("/auth/logout", Some("dbx_session=first"), json!({})).await.status(),
                StatusCode::OK
            );
            assert!(!pending.is_finished());
            let other = routes.post("/pl-debug/status", Some("dbx_session=second"), json!({"reference":second})).await;
            assert_eq!(other.status(), StatusCode::OK);
            assert_eq!(other.json::<Value>().await.unwrap()["state"], "paused");
            assert_eq!(events(&state, "pl_debug_close"), 0);
            std::fs::write(driver.join("inspect-gate"), b"1").unwrap();
            assert_eq!(pending.await.unwrap().status(), StatusCode::FORBIDDEN);
            wait_events(&state, "shutdown", 1).await;
            assert_eq!(events(&state, "close_session"), 1);
            assert_eq!(events(&state, "pl_debug_inspect"), 1);
            assert_eq!(events(&state, "pl_debug_start"), 1);
            routes.post("/auth/logout", Some("dbx_session=second"), json!({})).await;
            wait_events(&state, "shutdown", 2).await;
        }
    }
}