@team-agent/installer 0.5.1 → 0.5.3

package/Cargo.lock

@@ -91,7 +91,16 @@ dependencies = [
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-link",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "conpty-transport"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "windows",
 ]
 
 [[package]]
@@ -244,7 +253,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
@@ -357,7 +366,7 @@ dependencies = [
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -566,10 +575,11 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "chrono",
+ "conpty-transport",
  "libc",
  "regex",
  "rusqlite",
@@ -578,6 +588,7 @@ dependencies = [
  "serial_test",
  "sha2",
  "thiserror",
+ "windows",
 ]
 
 [[package]]
@@ -669,6 +680,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "win-conpty-phase0"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "conpty-transport",
+ "serde",
+ "serde_json",
+ "windows",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -691,6 +713,41 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core 0.61.2",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"
@@ -699,9 +756,20 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
  "windows-implement",
  "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading",
 ]
 
 [[package]]
@@ -726,19 +794,53 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
 ]
 
 [[package]]
@@ -747,7 +849,16 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
 ]
 
 [[package]]

package/Cargo.toml

@@ -5,11 +5,11 @@
 # 等抽成独立成员 crate(届时各自顶上 §10 的 deny 锁 + cargo-deny ban)。
 [workspace]
 resolver = "2"
-members = ["crates/team-agent"]
+members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-transport"]
 
 [workspace.package]
 edition = "2021"
-version = "0.5.1"
+version = "0.5.3"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/Cargo.toml

@@ -16,6 +16,7 @@ path = "src/main.rs"
 # step 2 (model) 已落地: serde/serde_json/thiserror/sha2。
 # rusqlite 仍留 workspace 调色板,step 3 (db) 再加(且需联网先 fetch)。
 [dependencies]
+conpty-transport = { path = "../conpty-transport" }
 anyhow.workspace = true
 thiserror.workspace = true
 serde.workspace = true
@@ -26,6 +27,26 @@ chrono.workspace = true
 libc.workspace = true
 rusqlite.workspace = true       # step 3 db(bundled SQLite,静态链接)
 
+# 0.5.x Windows portability Batch 2/3: uses the same `windows = "0.61"`
+# crate as `win-conpty-phase0` so the workspace shares a single
+# Windows-API crate + already-locked Cargo.lock version.
+#
+# - Batch 2 (`platform::file_lock`): `Win32_Storage_FileSystem`
+#   (`LockFileEx`/`UnlockFileEx`) + `Win32_System_IO::OVERLAPPED`.
+# - Batch 3 (`platform::process`): `Win32_System_Threading`
+#   (`OpenProcess`, `TerminateProcess`, `GetExitCodeProcess`,
+#   `GetCurrentProcessId`) + `Win32_System_Diagnostics_ToolHelp`
+#   (Toolhelp snapshot for parent-pid discovery).
+[target.'cfg(windows)'.dependencies.windows]
+version = "0.61"
+features = [
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+    "Win32_System_IO",
+    "Win32_System_Threading",
+    "Win32_System_Diagnostics_ToolHelp",
+]
+
 [dev-dependencies]
 serial_test = { version = "3", features = ["file_locks"] }
 

package/crates/team-agent/src/app_server_test_support.rs

@@ -0,0 +1,258 @@
+use serde_json::{json, Value};
+use std::io::{Read, Write};
+use std::os::unix::net::{UnixListener, UnixStream};
+use std::path::PathBuf;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc, Mutex,
+};
+use std::thread::JoinHandle;
+use std::time::Duration;
+
+#[derive(Clone)]
+pub(crate) struct FakeAppServerScript {
+    pub user_agent: Option<String>,
+    pub thread_id: String,
+    pub session_id: String,
+    pub cwd: String,
+    pub resume_error: Option<String>,
+    pub turn_error: Option<String>,
+    pub turn_status: String,
+}
+
+impl FakeAppServerScript {
+    pub(crate) fn happy(thread_id: &str, session_id: &str, cwd: &str) -> Self {
+        Self {
+            user_agent: Some("codex-appserver-team-agent-test/0.139.0".to_string()),
+            thread_id: thread_id.to_string(),
+            session_id: session_id.to_string(),
+            cwd: cwd.to_string(),
+            resume_error: None,
+            turn_error: None,
+            turn_status: "inProgress".to_string(),
+        }
+    }
+}
+
+pub(crate) struct FakeAppServer {
+    endpoint: String,
+    path: PathBuf,
+    received_turns: Arc<Mutex<Vec<Value>>>,
+    running: Arc<AtomicBool>,
+    handle: Option<JoinHandle<()>>,
+}
+
+impl FakeAppServer {
+    pub(crate) fn start(tag: &str, script: FakeAppServerScript) -> Self {
+        static NEXT_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+        let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
+        let path = PathBuf::from(format!("/tmp/taas-{}-{id}-{tag}.sock", std::process::id()));
+        let _ = std::fs::remove_file(&path);
+        let listener = UnixListener::bind(&path).unwrap();
+        listener.set_nonblocking(true).unwrap();
+        let received_turns = Arc::new(Mutex::new(Vec::new()));
+        let running = Arc::new(AtomicBool::new(true));
+        let thread_turns = Arc::clone(&received_turns);
+        let thread_running = Arc::clone(&running);
+        let thread_path = path.clone();
+        let handle = std::thread::spawn(move || {
+            while thread_running.load(Ordering::Relaxed) {
+                match listener.accept() {
+                    Ok((mut stream, _)) => {
+                        let _ = handle_connection(&mut stream, &script, &thread_turns);
+                    }
+                    Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => {
+                        std::thread::sleep(Duration::from_millis(10));
+                    }
+                    Err(_) => break,
+                }
+            }
+            let _ = std::fs::remove_file(thread_path);
+        });
+        Self {
+            endpoint: format!("unix://{}", path.display()),
+            path,
+            received_turns,
+            running,
+            handle: Some(handle),
+        }
+    }
+
+    pub(crate) fn endpoint(&self) -> &str {
+        &self.endpoint
+    }
+
+    pub(crate) fn path(&self) -> &PathBuf {
+        &self.path
+    }
+
+    pub(crate) fn received_turns(&self) -> Vec<Value> {
+        self.received_turns.lock().unwrap().clone()
+    }
+}
+
+impl Drop for FakeAppServer {
+    fn drop(&mut self) {
+        self.running.store(false, Ordering::Relaxed);
+        let _ = UnixStream::connect(&self.path);
+        if let Some(handle) = self.handle.take() {
+            let _ = handle.join();
+        }
+        let _ = std::fs::remove_file(&self.path);
+    }
+}
+
+fn handle_connection(
+    stream: &mut UnixStream,
+    script: &FakeAppServerScript,
+    turns: &Arc<Mutex<Vec<Value>>>,
+) -> std::io::Result<()> {
+    stream.set_nonblocking(false)?;
+    stream.set_read_timeout(Some(Duration::from_secs(3)))?;
+    stream.set_write_timeout(Some(Duration::from_secs(3)))?;
+    read_http_upgrade(stream)?;
+    stream.write_all(
+        b"HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: test\r\n\r\n",
+    )?;
+    while let Some(frame) = read_ws_text(stream)? {
+        let value: Value = match serde_json::from_str(&frame) {
+            Ok(value) => value,
+            Err(_) => continue,
+        };
+        let method = value.get("method").and_then(Value::as_str).unwrap_or("");
+        let id = value.get("id").cloned().unwrap_or(Value::Null);
+        match method {
+            "initialize" => {
+                let mut result = serde_json::Map::new();
+                result.insert("codexHome".to_string(), json!("/tmp/codex-home"));
+                result.insert("platformFamily".to_string(), json!("unix"));
+                result.insert("platformOs".to_string(), json!("macos"));
+                if let Some(user_agent) = &script.user_agent {
+                    result.insert("userAgent".to_string(), json!(user_agent));
+                }
+                write_ws_text(
+                    stream,
+                    &json!({"id": id, "result": Value::Object(result)}).to_string(),
+                )?;
+            }
+            "initialized" => {}
+            "thread/resume" => {
+                if let Some(message) = &script.resume_error {
+                    write_ws_text(
+                        stream,
+                        &json!({"id": id, "error": {"code": -32600, "message": message}})
+                            .to_string(),
+                    )?;
+                } else {
+                    write_ws_text(
+                        stream,
+                        &json!({
+                            "id": id,
+                            "result": {
+                                "cwd": script.cwd,
+                                "thread": {
+                                    "id": script.thread_id,
+                                    "sessionId": script.session_id,
+                                    "cwd": script.cwd,
+                                    "ephemeral": false
+                                }
+                            }
+                        })
+                        .to_string(),
+                    )?;
+                }
+            }
+            "turn/start" => {
+                turns.lock().unwrap().push(value.clone());
+                if let Some(message) = &script.turn_error {
+                    write_ws_text(
+                        stream,
+                        &json!({"id": id, "error": {"code": -32600, "message": message}})
+                            .to_string(),
+                    )?;
+                } else {
+                    write_ws_text(
+                        stream,
+                        &json!({
+                            "id": id,
+                            "result": {
+                                "turn": {"id": "turn-test", "status": script.turn_status}
+                            }
+                        })
+                        .to_string(),
+                    )?;
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+fn read_http_upgrade(stream: &mut UnixStream) -> std::io::Result<()> {
+    let mut data = Vec::new();
+    let mut buf = [0u8; 1];
+    while !data.ends_with(b"\r\n\r\n") {
+        stream.read_exact(&mut buf)?;
+        data.push(buf[0]);
+    }
+    Ok(())
+}
+
+fn read_ws_text(stream: &mut UnixStream) -> std::io::Result<Option<String>> {
+    let mut header = [0u8; 2];
+    match stream.read_exact(&mut header) {
+        Ok(()) => {}
+        Err(err)
+            if matches!(
+                err.kind(),
+                std::io::ErrorKind::UnexpectedEof
+                    | std::io::ErrorKind::WouldBlock
+                    | std::io::ErrorKind::TimedOut
+            ) =>
+        {
+            return Ok(None);
+        }
+        Err(err) => return Err(err),
+    }
+    let opcode = header[0] & 0x0f;
+    if opcode == 0x8 {
+        return Ok(None);
+    }
+    let masked = header[1] & 0x80 != 0;
+    let mut len = u64::from(header[1] & 0x7f);
+    if len == 126 {
+        let mut ext = [0u8; 2];
+        stream.read_exact(&mut ext)?;
+        len = u64::from(u16::from_be_bytes(ext));
+    } else if len == 127 {
+        let mut ext = [0u8; 8];
+        stream.read_exact(&mut ext)?;
+        len = u64::from_be_bytes(ext);
+    }
+    let mut mask = [0u8; 4];
+    if masked {
+        stream.read_exact(&mut mask)?;
+    }
+    let mut payload = vec![0u8; usize::try_from(len).unwrap_or(0)];
+    stream.read_exact(&mut payload)?;
+    if masked {
+        for (idx, byte) in payload.iter_mut().enumerate() {
+            *byte ^= mask[idx % 4];
+        }
+    }
+    Ok(Some(String::from_utf8_lossy(&payload).to_string()))
+}
+
+fn write_ws_text(stream: &mut UnixStream, text: &str) -> std::io::Result<()> {
+    let payload = text.as_bytes();
+    let mut frame = vec![0x81];
+    if payload.len() < 126 {
+        frame.push(payload.len() as u8);
+    } else {
+        frame.push(126);
+        frame.extend_from_slice(&(payload.len() as u16).to_be_bytes());
+    }
+    frame.extend_from_slice(payload);
+    stream.write_all(&frame)
+}

package/crates/team-agent/src/cli/adapters.rs

@@ -107,6 +107,7 @@ pub fn cmd_quick_start(args: &QuickStartArgs) -> Result<CmdResult, CliError> {
         args.team_id.as_deref(),
         args.yes,
         !args.no_display,
+        args.backend.as_deref(),
     )?;
     let readiness = value.get("readiness").and_then(Value::as_object);
     let all_resumable_have_session = readiness
@@ -716,8 +717,22 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
     .map_err(|e| CliError::Runtime(e.to_string()))?;
     let state = selected.state;
     let event_log = selected.run_workspace.join(".team").join("logs").join("events.jsonl");
-    let backend = crate::tmux_backend::TmuxBackend::for_workspace(&selected.run_workspace);
-    let (issues, suggested_repairs) = diagnose_runtime(&state, &backend);
+    // 0.5.x Phase 1d Batch 3: factory-routed diagnose backend so
+    // conpty teams get accurate `has_session` / capture from the shim
+    // rather than a workspace tmux fallback (which would always miss
+    // the ConPTY pane universe).
+    let backend: Box<dyn crate::transport::Transport> =
+        match crate::transport_factory::resolve_read_only_transport(
+            &selected.run_workspace,
+            Some(&state),
+            crate::transport_factory::TransportPurpose::Diagnose,
+        ) {
+            Ok(r) => r.backend,
+            Err(_) => Box::new(crate::tmux_backend::TmuxBackend::for_workspace(
+                &selected.run_workspace,
+            )),
+        };
+    let (issues, suggested_repairs) = diagnose_runtime(&state, backend.as_ref());
     let ok = issues.as_array().is_some_and(Vec::is_empty);
     Ok(CmdResult::from_json(
         json!({
@@ -801,7 +816,21 @@ pub fn cmd_peek(args: &PeekArgs) -> Result<CmdResult, CliError> {
     let Some((session, window, target)) = agent_pane_id(&state, &args.agent, agent_state) else {
         return Ok(peek_unavailable(&args.agent, args.json));
     };
-    let backend = crate::tmux_backend::TmuxBackend::for_workspace(&args.workspace);
+    // 0.5.x Phase 1d Batch 3: factory-routed peek backend so conpty
+    // teams peek from the shim scrollback rather than a workspace
+    // tmux capture that would always be empty. Tmux teams keep
+    // byte-equivalent behavior.
+    let backend: Box<dyn crate::transport::Transport> =
+        match crate::transport_factory::resolve_read_only_transport(
+            &args.workspace,
+            Some(&state),
+            crate::transport_factory::TransportPurpose::Status,
+        ) {
+            Ok(r) => r.backend,
+            Err(_) => Box::new(crate::tmux_backend::TmuxBackend::for_workspace(
+                &args.workspace,
+            )),
+        };
     let windows = backend
         .list_windows(&crate::transport::SessionName::new(session.clone()))
         .map_err(|e| CliError::Runtime(e.to_string()))?;

package/crates/team-agent/src/cli/attach_app_server_leader.rs

@@ -0,0 +1,16 @@
+use super::*;
+
+/// `team-agent attach-app-server-leader` writes a typed codex_app_server
+/// leader_receiver through the leader lease primitive.
+pub fn cmd_attach_app_server_leader(
+    args: &AttachAppServerLeaderArgs,
+) -> Result<CmdResult, CliError> {
+    let value = crate::leader::attach_app_server_leader(
+        &args.workspace,
+        args.team.as_deref(),
+        &args.socket,
+        &args.thread_id,
+    )
+    .map_err(|error| CliError::Runtime(error.to_string()))?;
+    Ok(CmdResult::from_json(value, args.json))
+}

package/crates/team-agent/src/cli/diagnose.rs

@@ -483,14 +483,23 @@ fn inject_tmux_session_present(workspace: &std::path::Path, state: &mut Value) {
         return;
     };
     let session_name_owned = session_name.to_string();
-    let selection = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+    // 0.5.x Phase 1d Batch 3: factory-routed read path. conpty state
+    // hits the shim; tmux state hits the persisted endpoint (byte-
+    // equivalent). Diagnose no longer reports `tmux_session_missing`
+    // for a conpty team just because it can't find a tmux session on
+    // the workspace socket (design §Batch 3 Verification anchor).
+    let resolved = crate::transport_factory::resolve_read_only_transport(
         workspace,
         Some(state),
+        crate::transport_factory::TransportPurpose::Diagnose,
     );
-    let present = selection
-        .backend
-        .has_session(&crate::transport::SessionName::new(session_name_owned))
-        .unwrap_or(false);
+    let present = match resolved {
+        Ok(r) => r
+            .backend
+            .has_session(&crate::transport::SessionName::new(session_name_owned))
+            .unwrap_or(false),
+        Err(_) => false,
+    };
     if let Value::Object(map) = state {
         map.insert("tmux_session_present".to_string(), Value::Bool(present));
     }