trusty-mpm 1.0.2

//! Integration tests for [`super::TmConnector`] (DOC-44 twin Phase 1, issue
//! #3007 test-layer (b)).
//!
//! Why: drives the connector against a REAL in-process daemon HTTP surface
//! (a real axum router bound to a random loopback port) rather than mocking
//! `reqwest` — the whole point of this connector is the wire contract with
//! the daemon's actual routes, so a mock would only prove the mock is
//! self-consistent. Mirrors `crates/trusty-mpm/src/client/proxy/tests.rs`'s
//! `spawn_test_daemon` pattern exactly (its own doc calls this "the isolated-
//! managed helper", duplicated here rather than shared because it is a
//! four-line, module-private test helper — not worth a cross-module `pub`
//! surface for).
//! What: session-lifecycle-independent tests (unknown-id error mapping,
//! wrong-`BackendParams` client-side rejection) run first, needing no git
//! binary. [`create_session_full_lifecycle`] is the one end-to-end test that
//! exercises the REAL `WorkspaceProvisioner`/`RealGitBackend` path — the
//! daemon's `spawn_managed_cloned` handler always uses `RealGitBackend`
//! (`crates/trusty-mpm/src/daemon/managed_routes/lifecycle.rs:564`), so a
//! hermetic spawn test needs a real (but local-only, no network) git repo —
//! mirroring `tests/session_manager_mvp.rs`'s `live_provision_real_repo`
//! fixture, except NOT `#[ignore]`-gated: cloning `file://<local bare repo>`
//! needs only the `git` binary already required to develop this workspace,
//! never the network. `with_root_isolated_managed`'s `FakeNoopTmuxDriver`
//! fakes every tmux operation (create/send/capture/list), so no real tmux is
//! ever touched.
//! Test: this file IS the test module (`#[path = "tm_tests.rs"] mod tests;`
//! in `tm.rs`). The unknown-id/not-found and create->list->status->send_input
//! assertions run through [`ConnectorTestKit`] (shared with
//! `crates/trusty-code/tests/connector_e2e.rs`) rather than being hand-rolled
//! here — only `attach`'s tm-specific `ShellCommand` shape and `delegate`'s
//! tm-specific gate+record semantics (which the kit deliberately does not
//! model — see [`ConnectorTestKit::assert_delegate_not_supported`]'s docs,
//! written for tcode's `NotSupported` contract, not tm's actually-supported
//! one) stay hand-rolled.

use std::future::IntoFuture;
use std::process::Command;

use tempfile::TempDir;
use trusty_agents_common::connectors::{
    AgentSpec, BackendParams, ConnectorTestKit, CreateSessionReq,
};

use super::*;

/// Spawn the daemon's real HTTP API on a random loopback port (empty fleet,
/// tmux faked). Mirrors `client::proxy::tests::spawn_test_daemon`, but —
/// unlike that helper — serves with `into_make_service_with_connect_info`
/// (matching `daemon::mod::run_http`'s real production wiring), because this
/// connector's `delegate` method calls the loopback-gated `POST /rpc` route,
/// which extracts `ConnectInfo<SocketAddr>` to enforce that gate (see
/// `daemon::api::rpc::rpc_handler`'s docs) — a plain `axum::serve(listener,
/// router)` never populates that extension and every `/rpc` call would 500.
///
/// Returns the root [`tempfile::TempDir`] guard alongside the URL — the
/// caller MUST hold it for the test's duration (#3450: the previous
/// `tempfile::tempdir().unwrap().keep()` both rooted under a possibly-polluted
/// `$TMPDIR` (see `crate::test_support`'s #3382 doc) AND permanently disabled
/// cleanup, so every test run left a fresh, un-reapable root behind).
async fn spawn_test_daemon() -> (tempfile::TempDir, String) {
    use crate::daemon::{api, state::DaemonState};
    let root_guard = crate::test_support::hermetic_temp_dir();
    let state = std::sync::Arc::new(
        DaemonState::with_root_isolated_managed(root_guard.path().to_owned()).await,
    );
    let router = api::router(std::sync::Arc::clone(&state));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();
    tokio::spawn(
        axum::serve(
            listener,
            router.into_make_service_with_connect_info::<std::net::SocketAddr>(),
        )
        .into_future(),
    );
    (root_guard, format!("http://{addr}"))
}

/// Build a local, offline-clonable bare git repo with one commit on `main`.
///
/// Why: [`create_session_full_lifecycle`] needs a `repo_url` the daemon's
/// REAL `RealGitBackend` can clone without ever touching the network.
/// What: `git init --bare -b main`, then clone/commit/push through a scratch
/// checkout — mirrors `tests/session_manager_mvp.rs`'s
/// `live_provision_real_repo` fixture. Returns the `TempDir` (kept alive for
/// the caller's duration) and the `file://` URL to the bare repo.
fn local_bare_repo() -> (TempDir, String) {
    let scratch = crate::test_support::hermetic_temp_dir();
    let bare = scratch.path().join("origin.git");
    let work = scratch.path().join("seed");
    assert!(
        Command::new("git")
            .args(["init", "--bare", "-b", "main"])
            .arg(&bare)
            .status()
            .map(|s| s.success())
            .unwrap_or(false),
        "git init --bare must succeed"
    );
    assert!(
        Command::new("git")
            .args(["clone"])
            .arg(&bare)
            .arg(&work)
            .status()
            .map(|s| s.success())
            .unwrap_or(false),
        "git clone (seed checkout) must succeed"
    );
    std::fs::write(work.join("README.md"), "seed").expect("write seed file");
    for args in [
        vec!["-C", work.to_str().unwrap(), "add", "."],
        vec![
            "-C",
            work.to_str().unwrap(),
            "-c",
            "user.email=connector-test@example.com",
            "-c",
            "user.name=connector-test",
            "commit",
            "-m",
            "seed",
        ],
        vec!["-C", work.to_str().unwrap(), "push", "origin", "main"],
    ] {
        assert!(
            Command::new("git")
                .args(&args)
                .status()
                .map(|s| s.success())
                .unwrap_or(false),
            "git {args:?} must succeed"
        );
    }
    let url = format!("file://{}", bare.display());
    (scratch, url)
}

/// `CreateSessionReq::backend` carrying `BackendParams::Tcode` must be
/// rejected client-side, before any HTTP call — a caller bug, not a daemon
/// round-trip.
#[tokio::test]
async fn create_session_wrong_backend_params_is_invalid_request() {
    let connector = TmConnector::with_daemon_url("http://127.0.0.1:0");
    let req = CreateSessionReq {
        task: "irrelevant".into(),
        name_hint: None,
        agent: None,
        backend: BackendParams::Tcode {
            project: std::path::PathBuf::from("/tmp/proj"),
        },
    };
    let err = connector.create_session(req).await.unwrap_err();
    assert!(
        matches!(err, ConnectorError::InvalidRequest(_)),
        "expected InvalidRequest, got {err:?}"
    );
}

#[tokio::test]
async fn list_sessions_empty_fleet_returns_empty_vec() {
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url);
    let sessions = connector.list_sessions().await.expect("list_sessions");
    assert!(sessions.is_empty(), "fresh daemon must have no sessions");
}

/// Shared conformance assertion — see [`ConnectorTestKit::assert_status_not_found_for_unknown_id`].
#[tokio::test]
async fn session_status_unknown_id_is_not_found() {
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url);
    ConnectorTestKit::assert_status_not_found_for_unknown_id(
        &connector,
        "00000000-0000-0000-0000-000000000000",
    )
    .await;
}

/// Shared conformance assertion — see [`ConnectorTestKit::assert_send_not_found_for_unknown_id`].
#[tokio::test]
async fn send_input_unknown_id_is_not_found() {
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url);
    ConnectorTestKit::assert_send_not_found_for_unknown_id(
        &connector,
        "00000000-0000-0000-0000-000000000000",
    )
    .await;
}

#[tokio::test]
async fn attach_unknown_id_is_not_found() {
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url);
    let err = connector
        .attach("00000000-0000-0000-0000-000000000000")
        .await
        .unwrap_err();
    assert!(err.is_not_found(), "expected NotFound, got {err:?}");
}

/// `delegate` against an unknown session must surface as a `Backend` error
/// (the `agent_delegate` MCP tool's own "no such session" domain rejection,
/// carried through the `tools/call` `isError: true` convention — never a
/// panic or a malformed-envelope `Transport` error).
#[tokio::test]
async fn delegate_unknown_session_is_backend_error() {
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url);
    let spec = AgentSpec {
        agent_name: "research".into(),
        task: "find the bug".into(),
        tier: None,
    };
    let err = connector
        .delegate("00000000-0000-0000-0000-000000000000", &spec)
        .await
        .unwrap_err();
    assert!(
        matches!(err, ConnectorError::Backend(_)),
        "expected Backend error for an unknown session, got {err:?}"
    );
}

/// End-to-end: create -> list -> status -> send_input (via
/// [`ConnectorTestKit::assert_basic_lifecycle`]) -> attach -> delegate,
/// against a REAL daemon spawn (real git clone via `RealGitBackend`, faked
/// tmux via `FakeNoopTmuxDriver`).
///
/// `#[serial_test::serial]` (#3450): this test mutates the process-global
/// `TRUSTY_MPM_WORKSPACE_ROOT` env var — see the override comment below.
#[tokio::test]
#[serial_test::serial]
async fn create_session_full_lifecycle() {
    let (_scratch, repo_url) = local_bare_repo();
    let (_daemon_root, url) = spawn_test_daemon().await;
    let connector = TmConnector::with_daemon_url(url.clone());

    // ── Hermetic workspace-provisioning root (#3450) ─────────────────────────
    // `DaemonState::with_root_isolated_managed` only isolates the session
    // manager's OWN metadata store (`root/session-manager`). The REAL
    // `spawn_managed` handler (`daemon/managed_routes/lifecycle.rs`)
    // independently calls `TrustyToolsConfig::load()` and resolves the
    // workspace-PROVISIONING root via `workspace_root(&config)`, which
    // defaults to the PRODUCTION `~/trusty-mpm-projects` whenever
    // `TRUSTY_MPM_WORKSPACE_ROOT` is unset — completely bypassing whatever
    // isolated root this test's `DaemonState` was built with. Compounding
    // this, `parse_github_path` treats ANY multi-segment URL (not just a
    // `github.com` one) as an owner/repo pair, so the `file://<scratch
    // tempdir>/origin.git` URL from `local_bare_repo()` launders the scratch
    // tempdir's OWN random name into "owner" — the exact
    // `~/trusty-mpm-projects/<tempdir-name>/origin/.base/...` shape observed
    // live in #3450. Pointing `TRUSTY_MPM_WORKSPACE_ROOT` at the SAME
    // hermetic `_daemon_root` this test already uses closes that gap.
    let prev_workspace_root =
        std::env::var(crate::core::trusty_tools_config::WORKSPACE_ROOT_ENV).ok();
    unsafe {
        std::env::set_var(
            crate::core::trusty_tools_config::WORKSPACE_ROOT_ENV,
            _daemon_root.path(),
        );
    }

    let req = CreateSessionReq {
        task: "list files".into(),
        name_hint: None,
        agent: None,
        backend: BackendParams::Tm {
            repo_url,
            git_ref: "main".into(),
            runtime: None,
            ephemeral: true,
        },
    };

    // NOT `ConnectorTestKit::assert_basic_lifecycle` (issue #3603 follow-up):
    // that helper's `send_input` step hard-asserts success, which assumes the
    // spawned session reaches `Active`. This test drives the REAL
    // `spawn_managed_cloned` handler (module docs above), which calls the
    // REAL `ClaudeCodeAdapter::spawn` — unlike every other tmux operation
    // here, that is NOT faked by `FakeNoopTmuxDriver`, and it resolves an
    // actual `claude` binary on `PATH`/well-known dirs
    // (`ClaudeCodeAdapter::resolve_claude`). On a developer machine with
    // Claude Code installed this succeeds and the record reaches `Active`;
    // on a CI runner with no `claude` binary it fails and
    // `spawn_managed_cloned` calls `mark_errored`, leaving the record
    // `Errored`. Before #3603's send_input readiness gate, this test's
    // `assert_basic_lifecycle` call "passed" in BOTH cases only because
    // `send_input` had no Provisioning/Errored guard at all — on an Errored
    // session that meant silently typing `echo hello` + Enter into a bare
    // shell with no runtime attached, i.e. exactly the shell-execution risk
    // #3603 closes. That was the test asserting broken (vulnerable)
    // behavior, not a real contract. Assert the CORRECT, environment-
    // independent contract instead: `send_input` must succeed for `Active`,
    // and must be refused (never silently accepted) for anything else.
    let info = connector
        .create_session(req)
        .await
        .expect("create_session must succeed for a well-formed request");
    assert!(
        !info.id.is_empty(),
        "create_session must return a non-empty session id"
    );

    let listed = connector
        .list_sessions()
        .await
        .expect("list_sessions must succeed");
    assert!(
        listed.iter().any(|s| s.id == info.id),
        "list_sessions must include the just-created session {}",
        info.id
    );

    let status = connector
        .session_status(&info.id)
        .await
        .expect("session_status must succeed for a known id");
    assert_eq!(
        status.id, info.id,
        "session_status must echo back the id it was asked about"
    );

    // `session_status`'s `state` is DISPLAY-reconciled against live tmux
    // (#3302): with `FakeNoopTmuxDriver` the tmux session never "exists", so
    // an `active` PERSISTED record is shown as `stopped` here regardless of
    // what actually gates `send_input` (which reads the PERSISTED state —
    // `SessionManager::check_send_input_ready` via `self.get(id)`, never the
    // display-reconciled view). Fetch the raw summary directly to read
    // `persisted_state`, the field the daemon's own docs say resume/restart
    // (and, by the same logic, this test's expectation) must key off of,
    // rather than predicting the gate's outcome from a value it does not
    // actually consult.
    let raw: ManagedSessionSummary = reqwest::Client::new()
        .get(format!("{url}/api/v1/sessions/managed/{}", info.id))
        .send()
        .await
        .expect("raw status GET must succeed")
        .json()
        .await
        .expect("raw status GET must decode as ManagedSessionSummary");
    let persisted_state = raw.persisted_state.as_deref().unwrap_or(&raw.state);

    match persisted_state {
        "active" => {
            connector
                .send_input(&info.id, "echo hello")
                .await
                .expect("send_input must succeed for an Active session");
        }
        other => {
            let err = connector
                .send_input(&info.id, "echo hello")
                .await
                .expect_err(&format!(
                    "send_input must be refused for a non-Active persisted state \
                     ({other}), never silently accepted"
                ));
            assert!(
                matches!(err, ConnectorError::Backend(_)),
                "expected a Backend refusal for persisted state {other:?}, got {err:?}"
            );
        }
    }

    // Restore the env var immediately after the one call that provisions a
    // workspace — attach/delegate below never re-provision.
    unsafe {
        match prev_workspace_root {
            Some(v) => std::env::set_var(crate::core::trusty_tools_config::WORKSPACE_ROOT_ENV, v),
            None => std::env::remove_var(crate::core::trusty_tools_config::WORKSPACE_ROOT_ENV),
        }
    }

    assert_eq!(
        info.task.as_deref(),
        Some("list files"),
        "create_session must echo back the task"
    );

    let attach = connector.attach(&info.id).await.expect("attach");
    match attach {
        AttachHandle::ShellCommand(cmd) => {
            assert!(
                cmd.contains("tmux attach"),
                "tm attach handle must be a tmux attach command, got {cmd:?}"
            );
        }
        other => panic!("tm connector must return ShellCommand, got {other:?}"),
    }

    let spec = AgentSpec {
        agent_name: "research".into(),
        task: "find the bug".into(),
        tier: Some("haiku".into()),
    };
    let handle = connector
        .delegate(&info.id, &spec)
        .await
        .expect("delegate must succeed against a live session");
    assert!(
        !handle.delegate_id.is_empty(),
        "delegate must return a non-empty delegate_id"
    );
}