reallink-cli 0.1.16 → 0.1.18

package/rust/src/main.rs

@@ -1,16 +1,26 @@
 use anyhow::{anyhow, Context, Result};
+use axum::extract::State;
+use axum::http::StatusCode as AxumStatusCode;
+use axum::routing::{get, post};
+use axum::{Json, Router};
+use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
+use base64::Engine;
 use clap::{ArgAction, Args, Parser, Subcommand, ValueEnum};
+use iroh::{endpoint::presets, Endpoint, EndpointAddr};
 use regex::RegexBuilder;
 use reqwest::{Method, StatusCode};
 use serde::{Deserialize, Serialize};
 use sha2::Digest;
 use std::fs;
 use std::io::{self, Read, SeekFrom, Write};
+use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tokio::fs as tokio_fs;
 use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncSeekExt, AsyncWriteExt, BufReader};
+use tokio::sync::RwLock;
 use tokio::time::sleep;
 
 mod generated;
@@ -18,7 +28,7 @@ mod logs;
 mod unreal;
 use unreal::{
     LinkConnectArgs, LinkDoctorArgs, LinkOpenArgs, LinkP2PCreateArgs, LinkP2PGetArgs,
-    LinkP2PListArgs, LinkP2PSignalArgs, LinkP2PWaitArgs, LinkPathsArgs, LinkPluginInstallArgs,
+    LinkP2PExecuteArgs, LinkP2PListArgs, LinkP2PSignalArgs, LinkP2PWaitArgs, LinkPathsArgs, LinkPluginInstallArgs,
     LinkPluginListArgs, LinkRemoveArgs, LinkRunArgs, LinkSourceArgs, LinkUnrealArgs, LinkUseArgs,
     PluginIndexFile, SourceLinkRecord, SourceLinksConfig, UnrealLinkRecord, UnrealLinksConfig,
 };
@@ -31,6 +41,11 @@ const UNREAL_LINKS_FILE_NAME: &str = "unreal-links.json";
 const UPDATE_CACHE_FILE_NAME: &str = "update-check.json";
 const VERSION_CHECK_INTERVAL_MS: u128 = 24 * 60 * 60 * 1000;
 const DEFAULT_VERSION_FETCH_TIMEOUT_MS: u64 = 800;
+const P2P_EXECUTE_SESSION_FETCH_ATTEMPTS: usize = 3;
+const P2P_EXECUTE_ENDPOINT_ATTEMPTS: usize = 3;
+const P2P_EXECUTE_RETRY_DELAY_MS: u64 = 350;
+const P2P_IROH_ALPN: &[u8] = b"reallink-p2p-direct-v1";
+const P2P_IROH_MAX_MESSAGE_BYTES: usize = 1024 * 1024;
 
 #[derive(Parser)]
 #[command(
@@ -7209,6 +7224,34 @@ pub(crate) async fn link_connect_command(
             args.transport.trim().to_lowercase()
         )
     });
+    let registered_client_id = Arc::new(RwLock::new(None::<String>));
+    let p2p_iroh_endpoint = if args.transport.trim().eq_ignore_ascii_case("p2p") {
+        Some(create_p2p_iroh_endpoint().await?)
+    } else {
+        None
+    };
+    let p2p_iroh_addr_json = if let Some(endpoint) = &p2p_iroh_endpoint {
+        Some(serde_json::to_string(&endpoint.addr()).context("encode p2p iroh addr")?)
+    } else {
+        None
+    };
+    let p2p_direct_servers = if args.transport.trim().eq_ignore_ascii_case("p2p") {
+        Some(
+            spawn_p2p_direct_server(
+                &args.p2p_listen,
+                &args.p2p_tcp_listen,
+                p2p_iroh_endpoint.clone().expect("missing p2p iroh endpoint"),
+                Arc::new(allowed_roots.clone()),
+                registered_client_id.clone(),
+                project_id.clone(),
+                base_url.to_string(),
+                access_token.to_string(),
+            )
+            .await?,
+        )
+    } else {
+        None
+    };
 
     // Reconnect loop with exponential backoff
     let mut backoff_ms: u64 = 1000;
@@ -7264,6 +7307,8 @@ pub(crate) async fn link_connect_command(
             "capabilities": ["stat", "read", "readRange", "readLines", "list", "search", "write", "mkdir", "delete"],
             "metadata": {
                 "cliVersion": env!("CARGO_PKG_VERSION"),
+                "irohAddrJson": p2p_iroh_addr_json,
+                "p2pCarrier": if args.transport.trim().eq_ignore_ascii_case("p2p") { Some("iroh-quic-v1") } else { None },
             }
         });
         if let Err(e) = ws_stream
@@ -7287,7 +7332,7 @@ pub(crate) async fn link_connect_command(
                 msg_opt = ws_stream.next() => {
                     match msg_opt {
                         Some(Ok(Message::Text(text))) => {
-                            if let Err(e) = handle_ws_message(&text, &allowed_roots, &mut ws_stream).await {
+                            if let Err(e) = handle_ws_message(&text, &allowed_roots, &registered_client_id, &mut ws_stream).await {
                                 eprintln!("Error handling message: {}", e);
                             }
                         },
@@ -7311,6 +7356,11 @@ pub(crate) async fn link_connect_command(
                 },
                 _ = tokio::signal::ctrl_c() => {
                     eprintln!("\nDisconnecting...");
+                    if let Some(servers) = &p2p_direct_servers {
+                        for server in servers {
+                            server.abort();
+                        }
+                    }
                     let _ = ws_stream.close(None).await;
                     return Ok(());
                 }
@@ -7539,9 +7589,711 @@ pub(crate) async fn link_p2p_signal_command(
     Ok(())
 }
 
+#[derive(Clone)]
+struct P2PDirectServerState {
+    allowed_roots: Arc<Vec<std::path::PathBuf>>,
+    client_id: Arc<RwLock<Option<String>>>,
+    project_id: String,
+    base_url: String,
+    access_token: String,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PDirectExecuteRequest {
+    session_id: String,
+    tool: String,
+    #[serde(default)]
+    input: serde_json::Value,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PSessionEnvelope {
+    session: P2PSessionRecord,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PSessionRecord {
+    session_id: String,
+    status: String,
+    signals: Vec<P2PSignalRecord>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PSignalRecord {
+    role: String,
+    signal_type: String,
+    from_client_id: Option<String>,
+    payload: serde_json::Value,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PDirectPeerInfo {
+    endpoint: String,
+    iroh_addr_json: Option<String>,
+    role: String,
+    from_client_id: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct P2PDirectTcpEnvelope {
+    session_id: String,
+    tool: String,
+    #[serde(default)]
+    input: serde_json::Value,
+    auth_token: String,
+}
+
+fn value_as_trimmed_string(value: Option<&serde_json::Value>) -> Option<String> {
+    value.and_then(|item| item.as_str()).map(|item| item.trim().to_string()).filter(|item| !item.is_empty())
+}
+
+async fn fetch_p2p_session(
+    client: &reqwest::Client,
+    base_url: &str,
+    access_token: &str,
+    project_id: &str,
+    session_id: &str,
+) -> Result<P2PSessionRecord> {
+    let endpoint = format!(
+        "{}/v1/projects/{}/connect/p2p/sessions/{}",
+        base_url.trim_end_matches('/'),
+        urlencoding::encode(project_id),
+        urlencoding::encode(session_id)
+    );
+    let response = client
+        .get(endpoint)
+        .bearer_auth(access_token)
+        .send()
+        .await
+        .context("fetch p2p session")?;
+    let status = response.status();
+    let payload: serde_json::Value = response.json().await.unwrap_or_else(|_| serde_json::json!({}));
+    if !status.is_success() {
+        return Err(anyhow!(
+            "fetch p2p session failed with status {}: {}",
+            status,
+            payload
+        ));
+    }
+    let parsed: P2PSessionEnvelope = serde_json::from_value(payload)
+        .context("parse p2p session response")?;
+    Ok(parsed.session)
+}
+
+fn p2p_should_retry_status(status: StatusCode) -> bool {
+    matches!(
+        status,
+        StatusCode::REQUEST_TIMEOUT
+            | StatusCode::TOO_MANY_REQUESTS
+            | StatusCode::BAD_GATEWAY
+            | StatusCode::SERVICE_UNAVAILABLE
+            | StatusCode::GATEWAY_TIMEOUT
+    ) || status.is_server_error()
+}
+
+fn resolve_target_signal(
+    session: &P2PSessionRecord,
+    target_role: &str,
+) -> Result<(P2PSignalRecord, P2PDirectPeerInfo, String)> {
+    for signal in session.signals.iter().rev() {
+        if signal.role != target_role {
+            continue;
+        }
+        let endpoint = value_as_trimmed_string(signal.payload.get("endpoint"))
+            .ok_or_else(|| anyhow!("target {} signal missing endpoint", target_role))?;
+        let iroh_addr_json = value_as_trimmed_string(signal.payload.get("irohAddrJson"));
+        let auth_token = value_as_trimmed_string(signal.payload.get("authToken"))
+            .ok_or_else(|| anyhow!("target {} signal missing authToken", target_role))?;
+        return Ok((
+            P2PSignalRecord {
+                role: signal.role.clone(),
+                signal_type: signal.signal_type.clone(),
+                from_client_id: signal.from_client_id.clone(),
+                payload: signal.payload.clone(),
+            },
+            P2PDirectPeerInfo {
+                endpoint,
+                iroh_addr_json,
+                role: signal.role.clone(),
+                from_client_id: signal.from_client_id.clone(),
+            },
+            auth_token,
+        ));
+    }
+    Err(anyhow!("no target {} signal with endpoint/authToken found", target_role))
+}
+
+fn candidate_peer_endpoints(endpoint: &str) -> Vec<String> {
+    let mut endpoints = vec![endpoint.to_string()];
+    if endpoint.contains("host.docker.internal") {
+        endpoints.push(endpoint.replace("host.docker.internal", "127.0.0.1"));
+        endpoints.push(endpoint.replace("host.docker.internal", "localhost"));
+    }
+    endpoints.dedup();
+    endpoints
+}
+
+async fn invoke_p2p_http_endpoint(
+    client: &reqwest::Client,
+    endpoint: &str,
+    auth_token: &str,
+    session_id: &str,
+    tool: &str,
+    input: &serde_json::Value,
+) -> Result<(StatusCode, serde_json::Value)> {
+    let response = client
+        .post(endpoint.to_string())
+        .header("x-reallink-p2p-token", auth_token)
+        .json(&serde_json::json!({
+            "sessionId": session_id,
+            "tool": tool,
+            "input": input,
+        }))
+        .send()
+        .await?;
+    let status = response.status();
+    let payload = response.json().await.unwrap_or_else(|_| serde_json::json!({}));
+    Ok((status, payload))
+}
+
+async fn invoke_p2p_tcp_endpoint(
+    endpoint: &str,
+    auth_token: &str,
+    session_id: &str,
+    tool: &str,
+    input: &serde_json::Value,
+) -> Result<(StatusCode, serde_json::Value)> {
+    let tcp_target = endpoint.trim_start_matches("tcp://");
+    let mut stream = tokio::net::TcpStream::connect(tcp_target).await
+        .with_context(|| format!("connect tcp p2p endpoint {}", endpoint))?;
+    let envelope = serde_json::to_string(&P2PDirectTcpEnvelope {
+        session_id: session_id.to_string(),
+        tool: tool.to_string(),
+        input: input.clone(),
+        auth_token: auth_token.to_string(),
+    })?;
+    stream.write_all(envelope.as_bytes()).await?;
+    stream.write_all(b"\n").await?;
+    let mut reader = BufReader::new(stream);
+    let mut line = String::new();
+    reader.read_line(&mut line).await?;
+    let payload: serde_json::Value = serde_json::from_str(line.trim())
+        .unwrap_or_else(|_| serde_json::json!({ "ok": false, "error": "invalid tcp response" }));
+    let status = if payload.get("ok").and_then(|value| value.as_bool()).unwrap_or(false) {
+        StatusCode::OK
+    } else {
+        StatusCode::BAD_GATEWAY
+    };
+    Ok((status, payload))
+}
+
+fn parse_iroh_addr(addr_json: &str) -> Result<EndpointAddr> {
+    serde_json::from_str(addr_json).context("parse iroh endpoint addr")
+}
+
+async fn create_p2p_iroh_endpoint() -> Result<Endpoint> {
+    let endpoint = Endpoint::builder(presets::N0)
+        .alpns(vec![P2P_IROH_ALPN.to_vec()])
+        .bind()
+        .await
+        .context("bind iroh endpoint")?;
+    endpoint.online().await;
+    Ok(endpoint)
+}
+
+async fn invoke_p2p_iroh_endpoint(
+    iroh_addr_json: &str,
+    auth_token: &str,
+    session_id: &str,
+    tool: &str,
+    input: &serde_json::Value,
+) -> Result<(StatusCode, serde_json::Value)> {
+    let endpoint_addr = parse_iroh_addr(iroh_addr_json)?;
+    let endpoint = create_p2p_iroh_endpoint().await?;
+    let connection = endpoint
+        .connect(endpoint_addr, P2P_IROH_ALPN)
+        .await
+        .context("connect iroh endpoint")?;
+    let (mut send, mut recv) = connection.open_bi().await.context("open iroh request stream")?;
+    let envelope = serde_json::to_vec(&P2PDirectTcpEnvelope {
+        session_id: session_id.to_string(),
+        tool: tool.to_string(),
+        input: input.clone(),
+        auth_token: auth_token.to_string(),
+    })?;
+    send.write_u32(envelope.len() as u32)
+        .await
+        .context("write iroh request length")?;
+    send.write_all(&envelope).await.context("write iroh request")?;
+    send.flush().await.context("flush iroh request")?;
+    send.finish().context("finish iroh request stream")?;
+    let response_len = recv
+        .read_u32()
+        .await
+        .context("read iroh response length")? as usize;
+    if response_len > P2P_IROH_MAX_MESSAGE_BYTES {
+        return Err(anyhow!(
+            "iroh response too large: {} bytes exceeds limit {}",
+            response_len,
+            P2P_IROH_MAX_MESSAGE_BYTES
+        ));
+    }
+    let mut response_bytes = vec![0; response_len];
+    recv.read_exact(&mut response_bytes)
+        .await
+        .map_err(|err| anyhow!("read iroh response: {:#}", err))?;
+    let payload: serde_json::Value = serde_json::from_slice(&response_bytes)
+        .unwrap_or_else(|_| serde_json::json!({ "ok": false, "error": "invalid iroh response" }));
+    let status = if payload.get("ok").and_then(|value| value.as_bool()).unwrap_or(false) {
+        StatusCode::OK
+    } else {
+        StatusCode::BAD_GATEWAY
+    };
+    connection.close(0u32.into(), b"done");
+    endpoint.close().await;
+    Ok((status, payload))
+}
+
+async fn p2p_direct_health() -> Json<serde_json::Value> {
+    Json(serde_json::json!({ "ok": true }))
+}
+
+async fn p2p_direct_execute(
+    State(state): State<P2PDirectServerState>,
+    headers: axum::http::HeaderMap,
+    Json(payload): Json<P2PDirectExecuteRequest>,
+) -> Result<Json<serde_json::Value>, (AxumStatusCode, Json<serde_json::Value>)> {
+    let presented_token = headers
+        .get("x-reallink-p2p-token")
+        .and_then(|value| value.to_str().ok())
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| {
+            (
+                AxumStatusCode::UNAUTHORIZED,
+                Json(serde_json::json!({ "ok": false, "error": "missing p2p token" })),
+            )
+        })?;
+
+    let registered_client_id = state.client_id.read().await.clone().ok_or_else(|| {
+        (
+            AxumStatusCode::SERVICE_UNAVAILABLE,
+            Json(serde_json::json!({ "ok": false, "error": "p2p client not registered yet" })),
+        )
+    })?;
+
+    let http_client = reqwest::Client::new();
+    let session = fetch_p2p_session(
+        &http_client,
+        &state.base_url,
+        &state.access_token,
+        &state.project_id,
+        &payload.session_id,
+    )
+    .await
+    .map_err(|err| {
+        (
+            AxumStatusCode::BAD_GATEWAY,
+            Json(serde_json::json!({ "ok": false, "error": err.to_string() })),
+        )
+    })?;
+
+    if session.status != "ready" {
+        return Err((
+            AxumStatusCode::CONFLICT,
+            Json(serde_json::json!({ "ok": false, "error": format!("p2p session {} not ready", session.session_id) })),
+        ));
+    }
+
+    let authorized = session.signals.iter().rev().find(|signal| {
+        signal.from_client_id.as_deref() == Some(registered_client_id.as_str())
+            && value_as_trimmed_string(signal.payload.get("authToken")).as_deref() == Some(presented_token.as_str())
+    });
+    if authorized.is_none() {
+        return Err((
+            AxumStatusCode::UNAUTHORIZED,
+            Json(serde_json::json!({ "ok": false, "error": "p2p token not authorized for this client/session" })),
+        ));
+    }
+
+    let result = execute_local_tool(&payload.tool, &payload.input, state.allowed_roots.as_slice()).await;
+    Ok(Json(result))
+}
+
+async fn execute_p2p_direct_request(
+    state: &P2PDirectServerState,
+    session_id: &str,
+    auth_token: &str,
+    tool: &str,
+    input: &serde_json::Value,
+) -> Result<serde_json::Value> {
+    let registered_client_id = state.client_id.read().await.clone()
+        .ok_or_else(|| anyhow!("p2p client not registered yet"))?;
+    let http_client = reqwest::Client::new();
+    let session = fetch_p2p_session(
+        &http_client,
+        &state.base_url,
+        &state.access_token,
+        &state.project_id,
+        session_id,
+    )
+    .await?;
+    if session.status != "ready" {
+        return Err(anyhow!("p2p session {} not ready", session.session_id));
+    }
+    let authorized = session.signals.iter().rev().find(|signal| {
+        signal.from_client_id.as_deref() == Some(registered_client_id.as_str())
+            && value_as_trimmed_string(signal.payload.get("authToken")).as_deref() == Some(auth_token)
+    });
+    if authorized.is_none() {
+        return Err(anyhow!("p2p token not authorized for this client/session"));
+    }
+    Ok(execute_local_tool(tool, input, state.allowed_roots.as_slice()).await)
+}
+
+async fn spawn_p2p_tcp_server(
+    listen_addr: &str,
+    state: P2PDirectServerState,
+) -> Result<tokio::task::JoinHandle<()>> {
+    let listener = tokio::net::TcpListener::bind(listen_addr)
+        .await
+        .with_context(|| format!("bind p2p tcp listen address {}", listen_addr))?;
+    let local_addr: SocketAddr = listener.local_addr().context("resolve p2p tcp local addr")?;
+    eprintln!("P2P TCP server listening on tcp://{}", local_addr);
+    let shared = Arc::new(state);
+    Ok(tokio::spawn(async move {
+        loop {
+            let (stream, _peer_addr) = match listener.accept().await {
+                Ok(value) => value,
+                Err(err) => {
+                    eprintln!("P2P TCP accept failed: {}", err);
+                    continue;
+                }
+            };
+            let state = shared.clone();
+            tokio::spawn(async move {
+                let (reader, mut writer) = stream.into_split();
+                let mut reader = BufReader::new(reader);
+                let mut line = String::new();
+                let response = match reader.read_line(&mut line).await {
+                    Ok(0) => serde_json::json!({ "ok": false, "error": "empty tcp request" }),
+                    Ok(_) => match serde_json::from_str::<P2PDirectTcpEnvelope>(line.trim()) {
+                        Ok(payload) => match execute_p2p_direct_request(
+                            &state,
+                            &payload.session_id,
+                            &payload.auth_token,
+                            &payload.tool,
+                            &payload.input,
+                        )
+                        .await
+                        {
+                            Ok(result) => result,
+                            Err(err) => serde_json::json!({ "ok": false, "error": err.to_string() }),
+                        },
+                        Err(err) => serde_json::json!({ "ok": false, "error": format!("invalid tcp request: {}", err) }),
+                    },
+                    Err(err) => serde_json::json!({ "ok": false, "error": format!("tcp read failed: {}", err) }),
+                };
+                let payload = match serde_json::to_string(&response) {
+                    Ok(value) => value,
+                    Err(err) => serde_json::json!({ "ok": false, "error": format!("tcp response encode failed: {}", err) }).to_string(),
+                };
+                let _ = writer.write_all(payload.as_bytes()).await;
+                let _ = writer.write_all(b"\n").await;
+                let _ = writer.shutdown().await;
+            });
+        }
+    }))
+}
+
+async fn spawn_p2p_iroh_server(
+    endpoint: Endpoint,
+    state: P2PDirectServerState,
+) -> Result<tokio::task::JoinHandle<()>> {
+    let local_addr_json = serde_json::to_string(&endpoint.addr()).context("encode iroh endpoint addr")?;
+    eprintln!("P2P iroh server online: {}", local_addr_json);
+    let shared = Arc::new(state);
+    Ok(tokio::spawn(async move {
+        loop {
+            let Some(connecting) = endpoint.accept().await else {
+                break;
+            };
+            let state = shared.clone();
+            tokio::spawn(async move {
+                let response = async {
+                    let connection = connecting.await.context("accept iroh connection")?;
+                    let (mut send, mut recv) =
+                        connection.accept_bi().await.context("accept iroh request stream")?;
+                    let request_len = recv
+                        .read_u32()
+                        .await
+                        .context("read iroh request length")? as usize;
+                    if request_len > P2P_IROH_MAX_MESSAGE_BYTES {
+                        return Err(anyhow!(
+                            "iroh request too large: {} bytes exceeds limit {}",
+                            request_len,
+                            P2P_IROH_MAX_MESSAGE_BYTES
+                        ));
+                    }
+                    let mut request_bytes = vec![0; request_len];
+                    recv.read_exact(&mut request_bytes)
+                        .await
+                        .context("read iroh request")?;
+                    let payload: P2PDirectTcpEnvelope = serde_json::from_slice(&request_bytes)
+                        .context("decode iroh request")?;
+                    let result = execute_p2p_direct_request(
+                        &state,
+                        &payload.session_id,
+                        &payload.auth_token,
+                        &payload.tool,
+                        &payload.input,
+                    )
+                    .await
+                    .unwrap_or_else(|err| serde_json::json!({ "ok": false, "error": err.to_string() }));
+                    let encoded = serde_json::to_vec(&result).context("encode iroh response")?;
+                    send.write_u32(encoded.len() as u32)
+                        .await
+                        .context("write iroh response length")?;
+                    send.write_all(&encoded).await.context("write iroh response")?;
+                    send.flush().await.context("flush iroh response")?;
+                    send.finish().context("finish iroh response stream")?;
+                    connection.closed().await;
+                    eprintln!("P2P iroh response sent ({} bytes)", encoded.len());
+                    Ok::<(), anyhow::Error>(())
+                }
+                .await;
+                if let Err(err) = response {
+                    eprintln!("P2P iroh connection failed: {:#}", err);
+                }
+            });
+        }
+    }))
+}
+
+async fn spawn_p2p_direct_server(
+    listen_addr: &str,
+    tcp_listen_addr: &str,
+    iroh_endpoint: Endpoint,
+    allowed_roots: Arc<Vec<std::path::PathBuf>>,
+    client_id: Arc<RwLock<Option<String>>>,
+    project_id: String,
+    base_url: String,
+    access_token: String,
+) -> Result<Vec<tokio::task::JoinHandle<()>>> {
+    let listener = tokio::net::TcpListener::bind(listen_addr)
+        .await
+        .with_context(|| format!("bind p2p listen address {}", listen_addr))?;
+    let state = P2PDirectServerState {
+        allowed_roots,
+        client_id,
+        project_id,
+        base_url,
+        access_token,
+    };
+    let app = Router::new()
+        .route("/health", get(p2p_direct_health))
+        .route("/execute", post(p2p_direct_execute))
+        .with_state(state.clone());
+    let local_addr: SocketAddr = listener.local_addr().context("resolve p2p server local addr")?;
+    eprintln!("P2P direct server listening on http://{}", local_addr);
+    let server = tokio::spawn(async move {
+        if let Err(err) = axum::serve(listener, app).await {
+            eprintln!("P2P direct server stopped: {}", err);
+        }
+    });
+    let tcp_server = spawn_p2p_tcp_server(tcp_listen_addr, state.clone()).await?;
+    let iroh_server = spawn_p2p_iroh_server(iroh_endpoint, state).await?;
+    Ok(vec![server, tcp_server, iroh_server])
+}
+
+pub(crate) async fn link_p2p_execute_command(
+    client: &reqwest::Client,
+    args: LinkP2PExecuteArgs,
+) -> Result<()> {
+    let auth = resolve_agent_auth(&AgentAuthArgs {
+        base_url: args.base_url.clone(),
+        access_token: args.access_token.clone(),
+    })?;
+    let (base_url, access_token) = match &auth {
+        AgentAuth::Session(session) => (session.base_url.clone(), session.access_token.clone()),
+        AgentAuth::Token {
+            base_url,
+            access_token,
+        } => (base_url.clone(), access_token.clone()),
+    };
+    let mut session: Option<P2PSessionRecord> = None;
+    let mut last_session_error: Option<anyhow::Error> = None;
+    for attempt in 1..=P2P_EXECUTE_SESSION_FETCH_ATTEMPTS {
+        match fetch_p2p_session(
+            client,
+            &base_url,
+            &access_token,
+            &args.project_id,
+            &args.session_id,
+        )
+        .await
+        {
+            Ok(value) => {
+                session = Some(value);
+                last_session_error = None;
+                break;
+            }
+            Err(err) => {
+                last_session_error = Some(err.context(format!(
+                    "fetch p2p session attempt {} of {}",
+                    attempt, P2P_EXECUTE_SESSION_FETCH_ATTEMPTS
+                )));
+                if attempt < P2P_EXECUTE_SESSION_FETCH_ATTEMPTS {
+                    sleep(Duration::from_millis(P2P_EXECUTE_RETRY_DELAY_MS * attempt as u64)).await;
+                }
+            }
+        }
+    }
+    let session = session.ok_or_else(|| {
+        last_session_error.unwrap_or_else(|| anyhow!("failed to fetch p2p session"))
+    })?;
+    if session.status != "ready" {
+        return Err(anyhow!("p2p session {} is not ready", session.session_id));
+    }
+    let (_signal, peer, auth_token) =
+        resolve_target_signal(&session, args.target_role.as_api_str())?;
+    let input = load_optional_json_body(args.input.as_deref())?
+        .unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
+    let input = serde_json::Value::Object(parse_object_from_value(input, "p2p execute input")?);
+    let mut last_error: Option<anyhow::Error> = None;
+    let mut response_payload = serde_json::json!({});
+    let mut status = StatusCode::BAD_GATEWAY;
+    let mut resolved_endpoint = peer.endpoint.clone();
+    if let Some(iroh_addr_json) = peer.iroh_addr_json.as_deref() {
+        for attempt in 1..=P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+            match invoke_p2p_iroh_endpoint(
+                iroh_addr_json,
+                &auth_token,
+                &args.session_id,
+                &args.tool,
+                &input,
+            )
+            .await
+            {
+                Ok((response_status, payload)) => {
+                    status = response_status;
+                    response_payload = payload;
+                    resolved_endpoint = "iroh://direct".to_string();
+                    if status.is_success() || !p2p_should_retry_status(status) || attempt == P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+                        last_error = None;
+                        break;
+                    }
+                }
+                Err(err) => {
+                    eprintln!("P2P iroh direct attempt failed: {:#}", err);
+                    last_error = Some(anyhow!(err).context(format!(
+                        "call p2p iroh endpoint attempt {} of {}",
+                        attempt, P2P_EXECUTE_ENDPOINT_ATTEMPTS
+                    )));
+                    if attempt < P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+                        sleep(Duration::from_millis(P2P_EXECUTE_RETRY_DELAY_MS * attempt as u64)).await;
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    if status.is_success() {
+        let output = serde_json::json!({
+            "ok": true,
+            "peer": {
+                "endpoint": resolved_endpoint,
+                "role": peer.role,
+                "fromClientId": peer.from_client_id,
+            },
+            "status": status.as_u16(),
+            "body": response_payload,
+        });
+        print_json(&output)?;
+        return Ok(());
+    }
+    for endpoint in candidate_peer_endpoints(&peer.endpoint) {
+        for attempt in 1..=P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+            let result = if endpoint.starts_with("tcp://") {
+                invoke_p2p_tcp_endpoint(
+                    &endpoint,
+                    &auth_token,
+                    &args.session_id,
+                    &args.tool,
+                    &input,
+                )
+                .await
+            } else {
+                invoke_p2p_http_endpoint(
+                    client,
+                    &endpoint,
+                    &auth_token,
+                    &args.session_id,
+                    &args.tool,
+                    &input,
+                )
+                .await
+            };
+            match result {
+                Ok((response_status, payload)) => {
+                    status = response_status;
+                    response_payload = payload;
+                    resolved_endpoint = endpoint.clone();
+                    if status.is_success() || !p2p_should_retry_status(status) || attempt == P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+                        last_error = None;
+                        break;
+                    }
+                    sleep(Duration::from_millis(P2P_EXECUTE_RETRY_DELAY_MS * attempt as u64)).await;
+                }
+                Err(err) => {
+                    last_error = Some(anyhow!(err).context(format!(
+                        "call p2p direct endpoint {} attempt {} of {}",
+                        endpoint, attempt, P2P_EXECUTE_ENDPOINT_ATTEMPTS
+                    )));
+                    if attempt < P2P_EXECUTE_ENDPOINT_ATTEMPTS {
+                        sleep(Duration::from_millis(P2P_EXECUTE_RETRY_DELAY_MS * attempt as u64)).await;
+                        continue;
+                    }
+                }
+            }
+            if status.is_success() || !p2p_should_retry_status(status) {
+                break;
+            }
+        }
+        if status.is_success() || !p2p_should_retry_status(status) {
+            break;
+        }
+    }
+    if let Some(err) = last_error {
+        return Err(err);
+    }
+    let output = serde_json::json!({
+        "ok": status.is_success() && response_payload.get("ok").and_then(|value| value.as_bool()).unwrap_or(false),
+        "peer": {
+            "endpoint": resolved_endpoint,
+            "role": peer.role,
+            "fromClientId": peer.from_client_id,
+        },
+        "status": status.as_u16(),
+        "body": response_payload,
+    });
+    print_json(&output)?;
+    if !status.is_success() {
+        return Err(anyhow!("link p2p execute failed with status {}", status));
+    }
+    Ok(())
+}
+
 async fn handle_ws_message(
     text: &str,
     allowed_roots: &[std::path::PathBuf],
+    registered_client_id: &Arc<RwLock<Option<String>>>,
     ws_stream: &mut (impl futures_util::Sink<
         tokio_tungstenite::tungstenite::Message,
         Error = tokio_tungstenite::tungstenite::Error,
@@ -7562,6 +8314,7 @@ async fn handle_ws_message(
     match msg_type {
         "registered" => {
             let client_id = msg.get("clientId").and_then(|v| v.as_str()).unwrap_or("?");
+            *registered_client_id.write().await = Some(client_id.to_string());
             eprintln!("Registered as {}", client_id);
         }
         "tool_request" => {
@@ -7635,14 +8388,22 @@ fn resolve_safe_path_allow_missing(
 ) -> Option<std::path::PathBuf> {
     for root in allowed_roots {
         let candidate = root.join(path_str);
-        if let Some(parent) = candidate.parent() {
-            if let Ok(resolved_parent) = parent.canonicalize() {
-                if resolved_parent.starts_with(root) {
+        let canonical_root = match root.canonicalize() {
+            Ok(value) => value,
+            Err(_) => continue,
+        };
+        if !candidate.starts_with(root) {
+            continue;
+        }
+        let mut probe = Some(candidate.as_path());
+        while let Some(current) = probe {
+            if let Ok(resolved_current) = current.canonicalize() {
+                if resolved_current.starts_with(&canonical_root) {
                     return Some(candidate);
                 }
+                break;
             }
-        } else if candidate.starts_with(root) {
-            return Some(candidate);
+            probe = current.parent();
         }
     }
     None
@@ -7686,6 +8447,7 @@ async fn execute_read_tool(
         return execute_read_range_tool(input, allowed_roots).await;
     }
     let path_str = input.get("path").and_then(|v| v.as_str()).unwrap_or("");
+    let encoding = input.get("encoding").and_then(|v| v.as_str()).unwrap_or("utf8");
     if path_str.is_empty() {
         return serde_json::json!({"ok": false, "error": "path required"});
     }
@@ -7693,8 +8455,17 @@ async fn execute_read_tool(
         Some(p) => p,
         None => return serde_json::json!({"ok": false, "error": "path not within allowed folders"}),
     };
-    match tokio::fs::read_to_string(&resolved).await {
-        Ok(content) => serde_json::json!({"ok": true, "data": content}),
+    match tokio::fs::read(&resolved).await {
+        Ok(content) => {
+            if encoding == "base64" {
+                serde_json::json!({"ok": true, "data": BASE64_STANDARD.encode(content)})
+            } else {
+                match String::from_utf8(content) {
+                    Ok(text) => serde_json::json!({"ok": true, "data": text}),
+                    Err(error) => serde_json::json!({"ok": false, "error": format!("file is not valid utf-8: {}", error)}),
+                }
+            }
+        }
         Err(e) => serde_json::json!({"ok": false, "error": e.to_string()}),
     }
 }
@@ -8003,7 +8774,22 @@ async fn execute_write_tool(
     allowed_roots: &[std::path::PathBuf],
 ) -> serde_json::Value {
     let path_str = input.get("path").and_then(|v| v.as_str()).unwrap_or("");
-    let content = input.get("content").and_then(|v| v.as_str()).unwrap_or("");
+    let encoding = input.get("encoding").and_then(|v| v.as_str()).unwrap_or_else(|| {
+        if input.get("contentBase64").and_then(|v| v.as_str()).is_some() {
+            "base64"
+        } else {
+            "utf8"
+        }
+    });
+    let content = if encoding == "base64" {
+        input
+            .get("contentBase64")
+            .and_then(|v| v.as_str())
+            .or_else(|| input.get("content").and_then(|v| v.as_str()))
+            .unwrap_or("")
+    } else {
+        input.get("content").and_then(|v| v.as_str()).unwrap_or("")
+    };
     let create_parents = input
         .get("createParents")
         .and_then(|v| v.as_bool())
@@ -8034,7 +8820,16 @@ async fn execute_write_tool(
         return serde_json::json!({"ok": false, "error": format!("file already exists: {}", path_str)});
     }
 
-    match tokio::fs::write(&resolved, content).await {
+    let payload = if encoding == "base64" {
+        match BASE64_STANDARD.decode(content) {
+            Ok(bytes) => bytes,
+            Err(error) => return serde_json::json!({"ok": false, "error": format!("invalid base64 content: {}", error)}),
+        }
+    } else {
+        content.as_bytes().to_vec()
+    };
+
+    match tokio::fs::write(&resolved, payload).await {
         Ok(_) => match tokio::fs::metadata(&resolved).await {
             Ok(metadata) => serde_json::json!({
                 "ok": true,