@team-agent/installer 0.5.71 → 0.5.73

package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs

@@ -15,10 +15,12 @@
 
 use std::collections::BTreeSet;
 use std::fs::OpenOptions;
-use std::io::Write;
+use std::io::{Read, Write};
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+use std::time::{Duration, Instant};
 
 use sha2::{Digest, Sha256};
 
@@ -586,6 +588,78 @@ fn executable_file_type(path: &Path) -> Result<PiExecutableFileType, ProviderErr
     }
 }
 
+/// Discover candidates with one PATH-first catalog observation. This deliberately
+/// does not resolve adapters or scan wrapper chains; callers use it only for
+/// rejecting an unqualified role model before lifecycle mutation.
+pub(crate) fn run_pi_catalog(
+    executable: &Path,
+    timeout: Duration,
+    max_bytes: u64,
+) -> Result<Vec<u8>, String> {
+    let mut child = Command::new(executable)
+        .arg("--list-models")
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .map_err(|_| "Pi executable is unavailable on PATH".to_string())?;
+    let stdout = child.stdout.take().ok_or_else(|| {
+        let _ = child.kill();
+        let _ = child.wait();
+        "Pi model catalog output unavailable".to_string()
+    })?;
+    let (sender, receiver) = mpsc::channel();
+    std::thread::spawn(move || {
+        let mut bytes = Vec::new();
+        let result = stdout.take(max_bytes + 1).read_to_end(&mut bytes);
+        let _ = sender.send((result, bytes));
+    });
+    let start = Instant::now();
+    loop {
+        match child.try_wait() {
+            Ok(Some(status)) => {
+                let (result, bytes) = receiver.recv_timeout(timeout.saturating_sub(start.elapsed()))
+                    .map_err(|_| "Pi model catalog command timed out".to_string())?;
+                if !status.success() { return Err("Pi model catalog command failed".into()); }
+                result.map_err(|_| "Pi model catalog could not be read".to_string())?;
+                if bytes.len() as u64 > max_bytes { return Err("Pi model catalog exceeds the bounded output limit".into()); }
+                return Ok(bytes);
+            }
+            Ok(None) if start.elapsed() < timeout => std::thread::sleep(Duration::from_millis(20)),
+            Ok(None) => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return Err("Pi model catalog command timed out".into());
+            }
+            Err(_) => {
+                let _ = child.kill();
+                let _ = child.wait();
+                return Err("Pi model catalog command could not be observed".into());
+            }
+        }
+    }
+}
+
+pub(crate) fn pi_model_candidates(requested: &str) -> Result<Vec<String>, ProviderError> {
+    let path = std::env::var_os("PATH")
+        .ok_or_else(|| ProviderError::Command("PATH is not set".to_string()))?;
+    let executable = std::env::split_paths(&path)
+        .map(|directory| directory.join("pi"))
+        .find(|candidate| candidate.is_file())
+        .ok_or_else(|| ProviderError::Command("Pi executable not found on PATH".to_string()))?;
+    let catalog = run_pi_catalog(&executable, Duration::from_secs(10), 1024 * 1024)
+        .map_err(ProviderError::Command)?;
+    let models = parse_pi_list_models_table(&catalog)?;
+    Ok(models
+        .into_iter()
+        .filter(|model| {
+            model
+                .rsplit_once('/')
+                .is_some_and(|(_, name)| name == requested)
+        })
+        .collect())
+}
+
 fn pi_path_entries() -> Result<Vec<PathBuf>, ProviderError> {
     let path = std::env::var_os("PATH")
         .ok_or_else(|| ProviderError::Command("PATH is not set".to_string()))?;
@@ -742,6 +816,27 @@ pub(crate) fn resolve_pi_executable_chain(
     Ok((chain, models))
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum PiSessionScope {
+    Isolated,
+    NativeDefault,
+}
+
+/// Zero-argument managed Pi is the interactive leader entry. Only that route
+/// may use Pi's cwd-keyed native session root; every explicit or worker route
+/// remains Team Agent session-isolated.
+pub(crate) fn pi_leader_session_scope(
+    provider_args: &[String],
+    external_path: bool,
+    allow_nested_attach: bool,
+) -> PiSessionScope {
+    if provider_args.is_empty() && !external_path && !allow_nested_attach {
+        PiSessionScope::NativeDefault
+    } else {
+        PiSessionScope::Isolated
+    }
+}
+
 pub(crate) struct PiMaterializeRequest<'a> {
     pub workspace: &'a Path,
     pub team_id: &'a str,
@@ -752,11 +847,13 @@ pub(crate) struct PiMaterializeRequest<'a> {
     pub tool_categories: &'a [&'a str],
     pub team_mcp_tools: &'a [&'a str],
     pub mcp_config: &'a McpConfig,
+    pub session_scope: PiSessionScope,
 }
 
 /// ---
 /// purpose: 共享物化 Pi leader 与 TeamMate 的 wrapper、UUID 和 CommandPlan
-/// returns: fresh Pi CommandPlan，含 expected UUID 与 seat session root
+/// returns: fresh Pi CommandPlan；isolated seats carry their session root, while the
+///          interactive leader preserves Pi's native default root
 /// errors: resolver、exact model、wrapper 或 argv 构造失败时返回 ProviderError
 /// ---
 pub(crate) fn materialize_pi_plan(
@@ -789,8 +886,18 @@ fn materialize_pi_plan_with_session(
         .map(|model| select_exact_pi_model(&catalog, model))
         .transpose()?;
     let paths = pi_seat_paths(request.workspace, request.team_id, request.agent_id);
+    let session_dir = match request.session_scope {
+        PiSessionScope::Isolated => Some(paths.sessions.as_path()),
+        PiSessionScope::NativeDefault => None,
+    };
     let resume = if let Some((session_id, session_path, spawn_cwd)) = resume {
-        let session_root = std::fs::canonicalize(&paths.sessions).map_err(|error| {
+        let session_dir = session_dir.ok_or_else(|| {
+            ProviderError::ResumeUnavailable(format!(
+                "Pi session root is unavailable {}",
+                paths.sessions.display()
+            ))
+        })?;
+        let session_root = std::fs::canonicalize(session_dir).map_err(|error| {
             ProviderError::ResumeUnavailable(format!(
                 "Pi session root is unavailable {}: {error}",
                 paths.sessions.display()
@@ -811,8 +918,11 @@ fn materialize_pi_plan_with_session(
         let _ = spawn_cwd;
         Some((session_id, exact_path))
     } else {
-        std::fs::create_dir_all(&paths.sessions)
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", paths.sessions.display())))?;
+        if let Some(session_dir) = session_dir {
+            std::fs::create_dir_all(session_dir).map_err(|error| {
+                ProviderError::Io(format!("{}: {error}", session_dir.display()))
+            })?;
+        }
         None
     };
     let candidate = candidate_from_mcp_config(request.mcp_config)?;
@@ -834,7 +944,7 @@ fn materialize_pi_plan_with_session(
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,
-            session_dir: &paths.sessions,
+            session_dir,
             session: PiSessionSelector::Resume { path: &exact_path },
             agent_id: request.agent_id,
         })?;
@@ -848,7 +958,7 @@ fn materialize_pi_plan_with_session(
             effort: request.effort,
             system_prompt: request.system_prompt,
             tool_categories: request.tool_categories,
-            session_dir: &paths.sessions,
+            session_dir,
             session: PiSessionSelector::Fresh {
                 session_id: session_id.as_str(),
             },
@@ -859,7 +969,7 @@ fn materialize_pi_plan_with_session(
     Ok(CommandPlan {
         argv,
         expected_session_id,
-        provider_projects_root: Some(paths.sessions),
+        provider_projects_root: session_dir.map(Path::to_path_buf),
         managed_mcp_config: false,
     })
 }