diff --git a/codex-rs/exec-server/src/local_file_system.rs b/codex-rs/exec-server/src/local_file_system.rs index 3129606d6b..f5cc597771 100644 --- a/codex-rs/exec-server/src/local_file_system.rs +++ b/codex-rs/exec-server/src/local_file_system.rs @@ -1,5 +1,10 @@ +use base64::Engine as _; +use base64::engine::general_purpose::STANDARD; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_path_uri::PathUri; +use futures::StreamExt; +use serde::Serialize; +use serde::de::DeserializeOwned; use std::path::Path; use std::path::PathBuf; use std::sync::Arc; @@ -15,6 +20,7 @@ use crate::CreateDirectoryOptions; use crate::ExecServerRuntimePaths; use crate::ExecutorFileSystem; use crate::ExecutorFileSystemFuture; +use crate::ExecutorRpcBatchCall; use crate::FILE_READ_CHUNK_SIZE; use crate::FileMetadata; use crate::FileSystemReadStream; @@ -22,10 +28,36 @@ use crate::FileSystemResult; use crate::FileSystemSandboxContext; use crate::ReadDirectoryEntry; use crate::RemoveOptions; +use crate::protocol::FS_CANONICALIZE_METHOD; +use crate::protocol::FS_COPY_METHOD; +use crate::protocol::FS_CREATE_DIRECTORY_METHOD; +use crate::protocol::FS_GET_METADATA_METHOD; +use crate::protocol::FS_READ_DIRECTORY_METHOD; +use crate::protocol::FS_READ_FILE_METHOD; +use crate::protocol::FS_REMOVE_METHOD; +use crate::protocol::FS_WRITE_FILE_METHOD; +use crate::protocol::FsCanonicalizeParams; +use crate::protocol::FsCanonicalizeResponse; +use crate::protocol::FsCopyParams; +use crate::protocol::FsCopyResponse; +use crate::protocol::FsCreateDirectoryParams; +use crate::protocol::FsCreateDirectoryResponse; +use crate::protocol::FsGetMetadataParams; +use crate::protocol::FsGetMetadataResponse; +use crate::protocol::FsReadDirectoryEntry; +use crate::protocol::FsReadDirectoryParams; +use crate::protocol::FsReadDirectoryResponse; +use crate::protocol::FsReadFileParams; +use crate::protocol::FsReadFileResponse; +use crate::protocol::FsRemoveParams; +use crate::protocol::FsRemoveResponse; +use crate::protocol::FsWriteFileParams; +use crate::protocol::FsWriteFileResponse; use crate::regular_file; use crate::sandboxed_file_system::SandboxedFileSystem; const MAX_READ_FILE_BYTES: u64 = 512 * 1024 * 1024; +const LOCAL_RPC_BATCH_CONCURRENCY: usize = 32; fn file_too_large_error() -> io::Error { io::Error::new( @@ -192,6 +224,124 @@ impl LocalFileSystem { .copy(source_path, destination_path, options, sandbox) .await } + + async fn execute_rpc_batch( + &self, + calls: Vec, + ) -> FileSystemResult>> { + Ok(futures::stream::iter(calls) + .map(|call| self.execute_rpc_request(call)) + .buffered(LOCAL_RPC_BATCH_CONCURRENCY) + .collect() + .await) + } + + async fn execute_rpc_request( + &self, + call: ExecutorRpcBatchCall, + ) -> FileSystemResult { + match call.method.as_str() { + FS_READ_FILE_METHOD => { + let params: FsReadFileParams = decode_rpc_params(call.params)?; + encode_rpc_response(FsReadFileResponse { + data_base64: STANDARD.encode( + self.read_file(¶ms.path, params.sandbox.as_ref()) + .await?, + ), + }) + } + FS_WRITE_FILE_METHOD => { + let params: FsWriteFileParams = decode_rpc_params(call.params)?; + let contents = STANDARD.decode(params.data_base64).map_err(|err| { + io::Error::new( + io::ErrorKind::InvalidData, + format!("fs/writeFile received invalid base64 dataBase64: {err}"), + ) + })?; + self.write_file(¶ms.path, contents, params.sandbox.as_ref()) + .await?; + encode_rpc_response(FsWriteFileResponse {}) + } + FS_CREATE_DIRECTORY_METHOD => { + let params: FsCreateDirectoryParams = decode_rpc_params(call.params)?; + self.create_directory( + ¶ms.path, + CreateDirectoryOptions { + recursive: params.recursive.unwrap_or(false), + }, + params.sandbox.as_ref(), + ) + .await?; + encode_rpc_response(FsCreateDirectoryResponse {}) + } + FS_GET_METADATA_METHOD => { + let params: FsGetMetadataParams = decode_rpc_params(call.params)?; + let metadata = self + .get_metadata(¶ms.path, params.sandbox.as_ref()) + .await?; + encode_rpc_response(FsGetMetadataResponse { + is_directory: metadata.is_directory, + is_file: metadata.is_file, + is_symlink: metadata.is_symlink, + size: metadata.size, + created_at_ms: metadata.created_at_ms, + modified_at_ms: metadata.modified_at_ms, + }) + } + FS_CANONICALIZE_METHOD => { + let params: FsCanonicalizeParams = decode_rpc_params(call.params)?; + encode_rpc_response(FsCanonicalizeResponse { + path: self + .canonicalize(¶ms.path, params.sandbox.as_ref()) + .await?, + }) + } + FS_READ_DIRECTORY_METHOD => { + let params: FsReadDirectoryParams = decode_rpc_params(call.params)?; + let entries = self + .read_directory(¶ms.path, params.sandbox.as_ref()) + .await? + .into_iter() + .map(|entry| FsReadDirectoryEntry { + file_name: entry.file_name, + is_directory: entry.is_directory, + is_file: entry.is_file, + }) + .collect(); + encode_rpc_response(FsReadDirectoryResponse { entries }) + } + FS_REMOVE_METHOD => { + let params: FsRemoveParams = decode_rpc_params(call.params)?; + self.remove( + ¶ms.path, + RemoveOptions { + recursive: params.recursive.unwrap_or(false), + force: params.force.unwrap_or(false), + }, + params.sandbox.as_ref(), + ) + .await?; + encode_rpc_response(FsRemoveResponse {}) + } + FS_COPY_METHOD => { + let params: FsCopyParams = decode_rpc_params(call.params)?; + self.copy( + ¶ms.source_path, + ¶ms.destination_path, + CopyOptions { + recursive: params.recursive, + }, + params.sandbox.as_ref(), + ) + .await?; + encode_rpc_response(FsCopyResponse {}) + } + method => Err(io::Error::new( + io::ErrorKind::InvalidInput, + format!("local filesystem RPC batch does not support `{method}`"), + )), + } + } } impl ExecutorFileSystem for LocalFileSystem { @@ -279,6 +429,21 @@ impl ExecutorFileSystem for LocalFileSystem { sandbox, )) } + + fn execute_rpc_batch<'a>( + &'a self, + calls: Vec, + ) -> ExecutorFileSystemFuture<'a, Vec>> { + Box::pin(LocalFileSystem::execute_rpc_batch(self, calls)) + } +} + +fn decode_rpc_params(params: serde_json::Value) -> FileSystemResult { + serde_json::from_value(params).map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err)) +} + +fn encode_rpc_response(response: T) -> FileSystemResult { + serde_json::to_value(response).map_err(io::Error::other) } impl UnsandboxedFileSystem {