use crate::error_code::internal_error; use crate::error_code::invalid_request; use crate::fs_watch::FsWatchManager; use crate::outgoing_message::ConnectionId; use base64::Engine; use base64::engine::general_purpose::STANDARD; use codex_app_server_protocol::FsCopyParams; use codex_app_server_protocol::FsCopyResponse; use codex_app_server_protocol::FsCreateDirectoryParams; use codex_app_server_protocol::FsCreateDirectoryResponse; use codex_app_server_protocol::FsGetMetadataParams; use codex_app_server_protocol::FsGetMetadataResponse; use codex_app_server_protocol::FsReadDirectoryEntry; use codex_app_server_protocol::FsReadDirectoryParams; use codex_app_server_protocol::FsReadDirectoryResponse; use codex_app_server_protocol::FsReadFileCloseParams; use codex_app_server_protocol::FsReadFileCloseResponse; use codex_app_server_protocol::FsReadFileOpenParams; use codex_app_server_protocol::FsReadFileOpenResponse; use codex_app_server_protocol::FsReadFileParams; use codex_app_server_protocol::FsReadFileReadParams; use codex_app_server_protocol::FsReadFileReadResponse; use codex_app_server_protocol::FsReadFileResponse; use codex_app_server_protocol::FsReadFileStatParams; use codex_app_server_protocol::FsReadFileStatResponse; use codex_app_server_protocol::FsRemoveParams; use codex_app_server_protocol::FsRemoveResponse; use codex_app_server_protocol::FsUnwatchParams; use codex_app_server_protocol::FsUnwatchResponse; use codex_app_server_protocol::FsWatchParams; use codex_app_server_protocol::FsWatchResponse; use codex_app_server_protocol::FsWriteFileCloseParams; use codex_app_server_protocol::FsWriteFileCloseResponse; use codex_app_server_protocol::FsWriteFileOpenParams; use codex_app_server_protocol::FsWriteFileOpenResponse; use codex_app_server_protocol::FsWriteFileParams; use codex_app_server_protocol::FsWriteFileResponse; use codex_app_server_protocol::FsWriteFileWriteParams; use codex_app_server_protocol::FsWriteFileWriteResponse; use codex_app_server_protocol::JSONRPCErrorError; use codex_exec_server::CopyOptions; use codex_exec_server::CreateDirectoryOptions; use codex_exec_server::EnvironmentManager; use codex_exec_server::ExecutorFileSystem; use codex_exec_server::FileHandleManager; use codex_exec_server::RemoveOptions; use std::collections::HashMap; use std::io; use std::sync::Arc; use tokio::sync::Mutex; #[derive(Clone)] pub(crate) struct FsRequestProcessor { environment_manager: Arc, fs_watch_manager: FsWatchManager, handles: Arc>>, } impl FsRequestProcessor { pub(crate) fn new( environment_manager: Arc, fs_watch_manager: FsWatchManager, ) -> Self { Self { environment_manager, fs_watch_manager, handles: Arc::new(Mutex::new(HashMap::new())), } } fn file_system(&self) -> Result, JSONRPCErrorError> { self.environment_manager .try_local_environment() .map(|environment| environment.get_filesystem()) .ok_or_else(|| internal_error("local filesystem is not configured")) } pub(crate) async fn connection_closed(&self, connection_id: ConnectionId) { let handles = self.handles.lock().await.remove(&connection_id); if let Some(handles) = handles { handles.close_all().await; } self.fs_watch_manager.connection_closed(connection_id).await; } async fn handles(&self, connection_id: ConnectionId) -> FileHandleManager { self.handles .lock() .await .entry(connection_id) .or_default() .clone() } async fn existing_handles(&self, connection_id: ConnectionId) -> Option { self.handles.lock().await.get(&connection_id).cloned() } pub(crate) async fn read_file( &self, params: FsReadFileParams, ) -> Result { let bytes = self .file_system()? .read_file(¶ms.path, /*sandbox*/ None) .await .map_err(map_fs_error)?; Ok(FsReadFileResponse { data_base64: STANDARD.encode(bytes), }) } pub(crate) async fn write_file( &self, params: FsWriteFileParams, ) -> Result { let bytes = STANDARD.decode(params.data_base64).map_err(|err| { invalid_request(format!( "fs/writeFile requires valid base64 dataBase64: {err}" )) })?; self.file_system()? .write_file(¶ms.path, bytes, /*sandbox*/ None) .await .map_err(map_fs_error)?; Ok(FsWriteFileResponse {}) } pub(crate) async fn read_file_open( &self, connection_id: ConnectionId, params: FsReadFileOpenParams, ) -> Result { let max_chunk_bytes = self .handles(connection_id) .await .open_read( self.file_system()?, params.handle_id, ¶ms.path, /*sandbox*/ None, ) .await .map_err(map_file_handle_error)?; Ok(FsReadFileOpenResponse { max_chunk_bytes: u32::try_from(max_chunk_bytes) .map_err(|_| internal_error("file read chunk limit exceeds u32"))?, }) } pub(crate) async fn read_file_read( &self, connection_id: ConnectionId, params: FsReadFileReadParams, ) -> Result { let chunk = self .handles(connection_id) .await .read( ¶ms.handle_id, params.offset, params.max_bytes.map(|value| value as usize), ) .await .map_err(map_file_handle_error)?; Ok(FsReadFileReadResponse { data_base64: STANDARD.encode(chunk.data), eof: chunk.eof, }) } pub(crate) async fn read_file_stat( &self, connection_id: ConnectionId, params: FsReadFileStatParams, ) -> Result { let metadata = self .handles(connection_id) .await .stat_read(¶ms.handle_id) .await .map_err(map_file_handle_error)?; Ok(FsReadFileStatResponse { size_bytes: metadata.size_bytes, created_at_ms: metadata.created_at_ms, modified_at_ms: metadata.modified_at_ms, }) } pub(crate) async fn read_file_close( &self, connection_id: ConnectionId, params: FsReadFileCloseParams, ) -> Result { if let Some(handles) = self.existing_handles(connection_id).await { handles.close(¶ms.handle_id).await; } Ok(FsReadFileCloseResponse {}) } pub(crate) async fn write_file_open( &self, connection_id: ConnectionId, params: FsWriteFileOpenParams, ) -> Result { let max_chunk_bytes = self .handles(connection_id) .await .open_write( self.file_system()?, params.handle_id, ¶ms.path, /*sandbox*/ None, ) .await .map_err(map_file_handle_error)?; Ok(FsWriteFileOpenResponse { max_chunk_bytes: u32::try_from(max_chunk_bytes) .map_err(|_| internal_error("file write chunk limit exceeds u32"))?, }) } pub(crate) async fn write_file_write( &self, connection_id: ConnectionId, params: FsWriteFileWriteParams, ) -> Result { let data = STANDARD.decode(params.data_base64).map_err(|err| { invalid_request(format!( "fs/writeFile/write requires valid base64 dataBase64: {err}" )) })?; self.handles(connection_id) .await .write(¶ms.handle_id, &data) .await .map_err(map_file_handle_error)?; Ok(FsWriteFileWriteResponse {}) } pub(crate) async fn write_file_close( &self, connection_id: ConnectionId, params: FsWriteFileCloseParams, ) -> Result { if let Some(handles) = self.existing_handles(connection_id).await { handles.close(¶ms.handle_id).await; } Ok(FsWriteFileCloseResponse {}) } pub(crate) async fn create_directory( &self, params: FsCreateDirectoryParams, ) -> Result { self.file_system()? .create_directory( ¶ms.path, CreateDirectoryOptions { recursive: params.recursive.unwrap_or(true), }, /*sandbox*/ None, ) .await .map_err(map_fs_error)?; Ok(FsCreateDirectoryResponse {}) } pub(crate) async fn get_metadata( &self, params: FsGetMetadataParams, ) -> Result { let metadata = self .file_system()? .get_metadata(¶ms.path, /*sandbox*/ None) .await .map_err(map_fs_error)?; Ok(FsGetMetadataResponse { is_directory: metadata.is_directory, is_file: metadata.is_file, is_symlink: metadata.is_symlink, created_at_ms: metadata.created_at_ms, modified_at_ms: metadata.modified_at_ms, }) } pub(crate) async fn read_directory( &self, params: FsReadDirectoryParams, ) -> Result { let entries = self .file_system()? .read_directory(¶ms.path, /*sandbox*/ None) .await .map_err(map_fs_error)?; Ok(FsReadDirectoryResponse { entries: entries .into_iter() .map(|entry| FsReadDirectoryEntry { file_name: entry.file_name, is_directory: entry.is_directory, is_file: entry.is_file, }) .collect(), }) } pub(crate) async fn remove( &self, params: FsRemoveParams, ) -> Result { self.file_system()? .remove( ¶ms.path, RemoveOptions { recursive: params.recursive.unwrap_or(true), force: params.force.unwrap_or(true), }, /*sandbox*/ None, ) .await .map_err(map_fs_error)?; Ok(FsRemoveResponse {}) } pub(crate) async fn copy( &self, params: FsCopyParams, ) -> Result { self.file_system()? .copy( ¶ms.source_path, ¶ms.destination_path, CopyOptions { recursive: params.recursive, }, /*sandbox*/ None, ) .await .map_err(map_fs_error)?; Ok(FsCopyResponse {}) } pub(crate) async fn watch( &self, connection_id: ConnectionId, params: FsWatchParams, ) -> Result { self.file_system()?; self.fs_watch_manager.watch(connection_id, params).await } pub(crate) async fn unwatch( &self, connection_id: ConnectionId, params: FsUnwatchParams, ) -> Result { self.file_system()?; self.fs_watch_manager.unwatch(connection_id, params).await } } fn map_fs_error(err: io::Error) -> JSONRPCErrorError { if err.kind() == io::ErrorKind::InvalidInput { invalid_request(err.to_string()) } else { internal_error(err.to_string()) } } fn map_file_handle_error(err: io::Error) -> JSONRPCErrorError { match err.kind() { io::ErrorKind::AlreadyExists | io::ErrorKind::InvalidInput | io::ErrorKind::NotFound => { invalid_request(err.to_string()) } _ => internal_error(err.to_string()), } }