@team-agent/installer 0.5.66 → 0.5.69

package/crates/team-agent/src/provider/session_scan/grok.rs

@@ -0,0 +1,288 @@
+//! ---
+//! purpose: 按 pending uuid 捕获 ~/.grok/sessions/<urlencoded-cwd>/<uuid>/，不读会话正文
+//! contract:
+//!   provides:
+//!     - name: grok_session_dir
+//!       what: 由 spawn cwd + session id 派生磁盘存档目录
+//!     - name: grok_session_archive_present
+//!       what: 只凭 marker 文件存在性判定 backing，不打开正文
+//!     - name: scan_session_store
+//!       what: expected_session_id 命中存档则返回唯一候选，否则空
+//!   requires:
+//!     - name: expected_session_id
+//!       what: 无 pending id 不扫描、不拾取同 cwd 其它会话
+//! boundary:
+//!   - 只服务 Provider::Grok
+//!   - 不读 chat_history/events 正文，不改 claude/codex/copilot 扫描
+//! maturity: wired
+//! ---
+
+use std::path::{Path, PathBuf};
+
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath};
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+/// RFC 3986 unreserved set — same as Python `urllib.parse.quote(path, safe='')`.
+fn percent_encode_unreserved(raw: &str) -> String {
+    let mut out = String::with_capacity(raw.len() * 3);
+    for &byte in raw.as_bytes() {
+        match byte {
+            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
+                out.push(byte as char);
+            }
+            _ => {
+                out.push('%');
+                const HEX: &[u8; 16] = b"0123456789ABCDEF";
+                out.push(HEX[(byte >> 4) as usize] as char);
+                out.push(HEX[(byte & 0x0F) as usize] as char);
+            }
+        }
+    }
+    out
+}
+
+/// ---
+/// purpose: 由 spawn cwd 与 session id 派生 ~/.grok/sessions 下的存档目录
+/// params:
+///   spawn_cwd: 席位工作目录；canonicalize 后再 percent-encode
+///   session_id: 框架预定 uuid；空或含路径分隔则拒绝
+/// returns: HOME 下对应目录路径；HOME 缺失或 id 非法则 None
+/// contract:
+///   provides:
+///     - name: grok_session_dir
+///       what: 只派生路径，不创建目录、不读存档
+/// boundary:
+///   - 不枚举其它 uuid，不读会话文件
+/// ---
+pub(crate) fn grok_session_dir(spawn_cwd: &Path, session_id: &str) -> Option<PathBuf> {
+    if session_id.is_empty()
+        || session_id.contains('/')
+        || session_id.contains('\\')
+        || session_id.contains('\0')
+    {
+        return None;
+    }
+    let home = std::env::var_os("HOME").map(PathBuf::from)?;
+    let canonical = std::fs::canonicalize(spawn_cwd).unwrap_or_else(|_| spawn_cwd.to_path_buf());
+    let encoded = percent_encode_unreserved(&canonical.to_string_lossy());
+    if encoded.is_empty() {
+        return None;
+    }
+    Some(
+        home.join(".grok")
+            .join("sessions")
+            .join(encoded)
+            .join(session_id),
+    )
+}
+
+/// ---
+/// purpose: 只凭 marker 文件存在性判断 grok 会话存档是否可 resume
+/// params:
+///   dir: grok_session_dir 给出的目录
+/// returns: 目录存在且含 events.jsonl 或 chat_history.jsonl 或 summary.json
+/// contract:
+///   provides:
+///     - name: grok_session_archive_present
+///       what: 用 is_file 判 backing，不打开正文
+/// boundary:
+///   - 不读 jsonl / summary 内容
+/// ---
+pub(crate) fn grok_session_archive_present(dir: &Path) -> bool {
+    if !dir.is_dir() {
+        return false;
+    }
+    ["events.jsonl", "chat_history.jsonl", "summary.json"]
+        .iter()
+        .any(|name| dir.join(name).is_file())
+}
+
+/// ---
+/// purpose: 按 pending expected_session_id 捕获唯一 grok 磁盘存档
+/// params:
+///   context: 含 spawn_cwd 与 expected_session_id 的捕获上下文
+/// returns: 命中则一条 FsWatch 候选，否则空向量
+/// contract:
+///   provides:
+///     - name: scan_session_store
+///       what: expected id 与目录对齐才捕获
+/// boundary:
+///   - 无 pending id 不扫描；不拾取同 cwd 其它会话
+/// ---
+pub(super) fn scan_session_store(context: &CaptureSessionContext) -> Vec<CapturedSessionCandidate> {
+    let Some(expected) = context.expected_session_id.as_ref() else {
+        return Vec::new();
+    };
+    let Some(dir) = grok_session_dir(&context.spawn_cwd, expected.as_str()) else {
+        return Vec::new();
+    };
+    if !grok_session_archive_present(&dir) {
+        return Vec::new();
+    }
+    vec![CapturedSessionCandidate {
+        captured: CapturedSession {
+            session_id: Some(expected.clone()),
+            rollout_path: Some(RolloutPath::new(dir)),
+            captured_via: CaptureVia::FsWatch,
+            attribution_confidence: Confidence::High,
+            spawn_cwd: context.spawn_cwd.clone(),
+        },
+        embedded_agent_id: None,
+        positive_agent_id_match: false,
+        agent_path_match: false,
+    }]
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+
+    use super::*;
+    use crate::provider::types::SessionId;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    struct HomeGuard {
+        prev: Option<std::ffi::OsString>,
+    }
+
+    impl HomeGuard {
+        fn set(home: &Path) -> Self {
+            let prev = std::env::var_os("HOME");
+            std::env::set_var("HOME", home);
+            Self { prev }
+        }
+    }
+
+    impl Drop for HomeGuard {
+        fn drop(&mut self) {
+            match &self.prev {
+                Some(v) => std::env::set_var("HOME", v),
+                None => std::env::remove_var("HOME"),
+            }
+        }
+    }
+
+    fn tmp_root(tag: &str) -> PathBuf {
+        static CTR: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-d111-grok-scan-{}-{}-{}",
+            tag,
+            std::process::id(),
+            CTR.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::canonicalize(&dir).unwrap()
+    }
+
+    fn seed_archive(home: &Path, cwd: &Path, session_id: &str) -> PathBuf {
+        let dir = grok_session_dir(cwd, session_id).expect("dir");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("events.jsonl"), b"").unwrap();
+        dir
+    }
+
+    fn ctx(cwd: &Path, expected: Option<&str>) -> CaptureSessionContext {
+        CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.to_path_buf(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: expected.map(SessionId::new),
+            provider_projects_root: None,
+        }
+    }
+
+    #[test]
+    fn grok_cwd_encoding_matches_python_quote_empty_safe() {
+        assert_eq!(
+            percent_encode_unreserved("/private/tmp/ta-t105-repro-83327/ws"),
+            "%2Fprivate%2Ftmp%2Fta-t105-repro-83327%2Fws"
+        );
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn grok_expected_id_captures_archive_without_reading_body() {
+        let base = tmp_root("hit");
+        let home = base.join("home");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&home).unwrap();
+        std::fs::create_dir_all(&cwd).unwrap();
+        let sid = "75fce302-0ce9-4635-a788-f4aec11a3f6a";
+        let _guard = HomeGuard::set(&home);
+        let dir = seed_archive(&home, &cwd, sid);
+        std::fs::write(
+            dir.join("chat_history.jsonl"),
+            b"THIS-BODY-MUST-NOT-BE-PARSED\n",
+        )
+        .unwrap();
+        let out = scan_session_store(&ctx(&cwd, Some(sid)));
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].captured.session_id.as_ref().unwrap().as_str(), sid);
+        assert_eq!(
+            out[0]
+                .captured
+                .rollout_path
+                .as_ref()
+                .map(|p| p.as_path().to_path_buf()),
+            Some(dir)
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn grok_expected_id_does_not_steal_foreign_cwd_archive() {
+        let base = tmp_root("foreign");
+        let home = base.join("home");
+        let cwd = base.join("ws");
+        let foreign = base.join("other");
+        std::fs::create_dir_all(&home).unwrap();
+        std::fs::create_dir_all(&cwd).unwrap();
+        std::fs::create_dir_all(&foreign).unwrap();
+        let sid = "4e7b5a6e-e09a-4291-9c75-563107105185";
+        let _guard = HomeGuard::set(&home);
+        seed_archive(&home, &foreign, sid);
+        let out = scan_session_store(&ctx(&cwd, Some(sid)));
+        assert!(
+            out.is_empty(),
+            "foreign cwd archive must not bind; got {out:?}"
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn grok_scan_without_expected_id_returns_empty() {
+        let base = tmp_root("no-pending");
+        let home = base.join("home");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&home).unwrap();
+        std::fs::create_dir_all(&cwd).unwrap();
+        let _guard = HomeGuard::set(&home);
+        seed_archive(&home, &cwd, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa");
+        let out = scan_session_store(&ctx(&cwd, None));
+        assert!(out.is_empty());
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn grok_scan_empty_dir_without_marker_is_not_backing() {
+        let base = tmp_root("empty");
+        let home = base.join("home");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&home).unwrap();
+        std::fs::create_dir_all(&cwd).unwrap();
+        let sid = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
+        let _guard = HomeGuard::set(&home);
+        let dir = grok_session_dir(&cwd, sid).unwrap();
+        std::fs::create_dir_all(&dir).unwrap();
+        assert!(!grok_session_archive_present(&dir));
+        assert!(scan_session_store(&ctx(&cwd, Some(sid))).is_empty());
+        let _ = std::fs::remove_dir_all(&base);
+    }
+}

package/crates/team-agent/src/provider/session_scan/pi.rs

@@ -0,0 +1,172 @@
+//! ---
+//! purpose: 在记录的 Pi 席位 session root 内按真实 header 捕获 exact JSONL backing
+//! contract:
+//!   provides:
+//!     - name: scan_session_store
+//!       what: 只读每个 JSONL 的首个完整 header，并按 id/cwd/spawned_at 返回候选
+//!     - name: validate_exact_backing
+//!       what: restart 前重验 exact path 的 id/cwd header
+//! boundary:
+//!   - 只递归 recorded provider_projects_root，不扫描 HOME 或消息正文
+//!   - 不以文件名、mtime 或唯一文件替代 header 匹配
+//! maturity: wired
+//! ---
+
+use std::io::BufRead;
+use std::path::{Path, PathBuf};
+
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
+use crate::provider::ProviderError;
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+#[derive(serde::Deserialize)]
+struct PiSessionHeader {
+    #[serde(rename = "type")]
+    record_type: String,
+    version: u64,
+    id: String,
+    cwd: PathBuf,
+    timestamp: String,
+}
+
+fn paths_equal(left: &Path, right: &Path) -> bool {
+    let left = std::fs::canonicalize(left).unwrap_or_else(|_| left.to_path_buf());
+    let right = std::fs::canonicalize(right).unwrap_or_else(|_| right.to_path_buf());
+    left == right
+}
+
+fn read_header(path: &Path) -> Option<PiSessionHeader> {
+    let file = std::fs::File::open(path).ok()?;
+    let mut first_line = String::new();
+    let bytes = std::io::BufReader::new(file)
+        .read_line(&mut first_line)
+        .ok()?;
+    if bytes == 0 || !first_line.ends_with('\n') {
+        return None;
+    }
+    let header: PiSessionHeader = serde_json::from_str(first_line.trim_end()).ok()?;
+    (header.record_type == "session" && header.version == 3).then_some(header)
+}
+
+fn header_matches(
+    header: &PiSessionHeader,
+    expected_session_id: &SessionId,
+    spawn_cwd: &Path,
+    spawned_at: Option<&str>,
+) -> bool {
+    if header.id != expected_session_id.as_str() || !paths_equal(&header.cwd, spawn_cwd) {
+        return false;
+    }
+    let Ok(header_timestamp) = chrono::DateTime::parse_from_rfc3339(&header.timestamp) else {
+        return false;
+    };
+    let Some(spawned_at) = spawned_at else {
+        return true;
+    };
+    let Ok(spawned_at) = chrono::DateTime::parse_from_rfc3339(spawned_at) else {
+        return false;
+    };
+    header_timestamp >= spawned_at
+}
+
+fn collect_jsonl(root: &Path, out: &mut Vec<PathBuf>) -> Result<(), ProviderError> {
+    let entries = std::fs::read_dir(root)
+        .map_err(|error| ProviderError::Io(format!("{}: {error}", root.display())))?;
+    for entry in entries {
+        let entry =
+            entry.map_err(|error| ProviderError::Io(format!("{}: {error}", root.display())))?;
+        let file_type = entry
+            .file_type()
+            .map_err(|error| ProviderError::Io(format!("{}: {error}", entry.path().display())))?;
+        if file_type.is_symlink() {
+            continue;
+        }
+        let path = entry.path();
+        if file_type.is_dir() {
+            collect_jsonl(&path, out)?;
+        } else if file_type.is_file() && path.extension().is_some_and(|ext| ext == "jsonl") {
+            out.push(path);
+        }
+    }
+    Ok(())
+}
+
+/// ---
+/// purpose: restart 前重验调用方给出的 exact Pi JSONL backing
+/// returns: header type/version/id/cwd 全匹配时成功
+/// errors: 文件缺失、header 不完整或 identity 不匹配时返回 ResumeUnavailable
+/// ---
+pub(crate) fn validate_exact_backing(
+    path: &Path,
+    expected_session_id: &SessionId,
+    spawn_cwd: &Path,
+) -> Result<(), ProviderError> {
+    if !path.is_file() {
+        return Err(ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing is missing: {}",
+            path.display()
+        )));
+    }
+    let header = read_header(path).ok_or_else(|| {
+        ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing has no complete session header: {}",
+            path.display()
+        ))
+    })?;
+    if !header_matches(&header, expected_session_id, spawn_cwd, None) {
+        return Err(ProviderError::ResumeUnavailable(format!(
+            "Pi exact session backing header does not match id/cwd: {}",
+            path.display()
+        )));
+    }
+    Ok(())
+}
+
+/// ---
+/// purpose: 仅在 recorded seat root 内递归捕获 Pi session header 候选
+/// returns: 每个 id/cwd/timestamp 精确匹配的 JSONL 各返回一个候选
+/// errors: root 内目录枚举失败时返回 ProviderError
+/// ---
+pub(super) fn scan_session_store(
+    context: &CaptureSessionContext,
+) -> Result<Vec<CapturedSessionCandidate>, ProviderError> {
+    let (Some(root), Some(expected_session_id), Some(spawned_at)) = (
+        context.provider_projects_root.as_deref(),
+        context.expected_session_id.as_ref(),
+        context.spawned_at.as_deref(),
+    ) else {
+        return Ok(Vec::new());
+    };
+    if !root.is_dir() {
+        return Ok(Vec::new());
+    }
+
+    let mut paths = Vec::new();
+    collect_jsonl(root, &mut paths)?;
+    paths.sort();
+    Ok(paths
+        .into_iter()
+        .filter_map(|path| {
+            let header = read_header(&path)?;
+            header_matches(
+                &header,
+                expected_session_id,
+                &context.spawn_cwd,
+                Some(spawned_at),
+            )
+            .then(|| CapturedSessionCandidate {
+                captured: CapturedSession {
+                    session_id: Some(expected_session_id.clone()),
+                    rollout_path: Some(RolloutPath::new(path)),
+                    captured_via: CaptureVia::FsWatch,
+                    attribution_confidence: Confidence::High,
+                    spawn_cwd: context.spawn_cwd.clone(),
+                },
+                embedded_agent_id: None,
+                positive_agent_id_match: false,
+                agent_path_match: false,
+            })
+        })
+        .collect())
+}

package/crates/team-agent/src/provider/session_scan.rs

@@ -14,6 +14,9 @@ pub(crate) mod claude;
 pub(crate) mod codex;
 pub(crate) mod common;
 pub(crate) mod copilot;
+pub(crate) mod cursor;
+pub(crate) mod grok;
+pub(crate) mod pi;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CaptureSessionContext {
@@ -41,6 +44,15 @@ pub(crate) fn scan_session_candidates_once(
     if matches!(provider, Provider::Copilot) {
         return Ok(copilot::scan_session_store(context));
     }
+    if matches!(provider, Provider::Grok) {
+        return Ok(grok::scan_session_store(context));
+    }
+    if matches!(provider, Provider::CursorAgent) {
+        return Ok(cursor::scan_session_store(context));
+    }
+    if matches!(provider, Provider::Pi) {
+        return pi::scan_session_store(context);
+    }
     if matches!(provider, Provider::Claude | Provider::ClaudeCode)
         && context.expected_session_id.is_some()
     {

package/crates/team-agent/src/provider/submit_now.rs

@@ -0,0 +1,94 @@
+//! ---
+//! purpose: grok 忙时默认把显式队列顶出去（再按回车）
+//! contract:
+//!   provides:
+//!     - name: flush_explicit_queue
+//!       what: 屏幕出现 grok `Enter:send now` 时只重按回车直到消失；默认不认 cursor 页脚
+//!   depends:
+//!     - crate::transport::Transport
+//! boundary:
+//!   - 不重粘文本、不用 Escape、不用 Ctrl-C、不加自动重投
+//!   - 不按忙闲决定发不发；只在已经注入之后确认队列态
+//!   - 无标记时不改 claude/codex 提交行为
+//!   - cursor 第二下 Enter 会打断进行中回合；生产 flush 不带 cursor 标记
+//! maturity: wired
+//! ---
+
+use std::time::Duration;
+
+use crate::transport::{CaptureRange, Key, Target, Transport, TransportError};
+
+/// grok 1.0.4 实测：页脚出现这串就是显式队列。
+pub const GROK_SEND_NOW_MARK: &str = "Enter:send now";
+
+/// 2026-08-18 真机，cursor-agent 2026.08.11-e8db854。
+/// 忙时 follow-ups 盒页脚原文（大小写按屏上）：
+/// `enter send now · ↑ select/edit · esc cancel`
+/// 出处：`.team/scripts/cursor_send.sh` 的 `QUEUE_MARK='enter send now'`
+/// （脚本头 2026-08-18 真机段）。与 grok 的 `Enter:send now`（大写 E、冒号）
+/// 不是同一串。
+pub const CURSOR_SEND_NOW_MARK: &str = "enter send now";
+
+/// 与 grok_send.sh / cursor_send.sh 对齐：最多再按 8 次回车。
+pub const GROK_SEND_NOW_MAX_ENTERS: u32 = 8;
+
+pub struct FlushReport {
+    pub extra_enters: u32,
+    pub mark_cleared: bool,
+}
+
+/// After paste+first Enter, if the pane still shows a queue footer,
+/// press Enter only until the mark is gone. No mark ⇒ no keys (claude/codex).
+pub fn flush_explicit_queue(
+    transport: &dyn Transport,
+    target: &Target,
+) -> Result<FlushReport, TransportError> {
+    flush_explicit_queue_for(transport, target, &[GROK_SEND_NOW_MARK])
+}
+
+/// One detector path at a time. Production flush is grok-only.
+/// Tests enable a single mark so a false-positive cannot hide behind the other path.
+pub fn flush_explicit_queue_for(
+    transport: &dyn Transport,
+    target: &Target,
+    marks: &[&str],
+) -> Result<FlushReport, TransportError> {
+    let mut extra_enters = 0;
+    for _ in 0..GROK_SEND_NOW_MAX_ENTERS {
+        let captured = transport.capture(target, CaptureRange::Tail(40))?;
+        if !queue_mark_visible_for(&captured.text, marks) {
+            return Ok(FlushReport {
+                extra_enters,
+                mark_cleared: true,
+            });
+        }
+        transport.send_keys(target, &[Key::Enter])?;
+        extra_enters = extra_enters.saturating_add(1);
+        std::thread::sleep(retry_pause());
+    }
+    let captured = transport.capture(target, CaptureRange::Tail(40))?;
+    Ok(FlushReport {
+        extra_enters,
+        mark_cleared: !queue_mark_visible_for(&captured.text, marks),
+    })
+}
+
+pub fn keep_provider_queue_requested() -> bool {
+    matches!(
+        std::env::var("TEAM_AGENT_KEEP_PROVIDER_QUEUE").as_deref(),
+        Ok("1") | Ok("true") | Ok("yes")
+    )
+}
+
+pub fn queue_mark_visible(text: &str) -> bool {
+    queue_mark_visible_for(text, &[GROK_SEND_NOW_MARK])
+}
+
+pub fn queue_mark_visible_for(text: &str, marks: &[&str]) -> bool {
+    marks.iter().any(|mark| text.contains(mark))
+}
+
+#[allow(dead_code)]
+fn retry_pause() -> Duration {
+    Duration::from_millis(50)
+}