Refactoring the structure a bit

server/src/io/fs.rs

@@ -0,0 +1,191 @@
+use crate::state::SessionState;
+use crate::store::StoreOps;
+use serde::Serialize;
+use serde_json::json;
+use std::fs;
+use std::path::PathBuf;
+
+const KEY_LAST_PROJECT: &str = "last_project_path";
+const KEY_SELECTED_MODEL: &str = "selected_model";
+
+/// Resolves a relative path against the active project root (pure function for testing).
+/// Returns error if path attempts traversal (..).
+fn resolve_path_impl(root: PathBuf, relative_path: &str) -> Result<PathBuf, String> {
+    if relative_path.contains("..") {
+        return Err("Security Violation: Directory traversal ('..') is not allowed.".to_string());
+    }
+
+    Ok(root.join(relative_path))
+}
+
+/// Resolves a relative path against the active project root.
+/// Returns error if no project is open or if path attempts traversal (..).
+fn resolve_path(state: &SessionState, relative_path: &str) -> Result<PathBuf, String> {
+    let root = state.get_project_root()?;
+    resolve_path_impl(root, relative_path)
+}
+
+/// Validate that a path exists and is a directory (pure function for testing)
+async fn validate_project_path(path: PathBuf) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        if !path.exists() {
+            return Err(format!("Path does not exist: {}", path.display()));
+        }
+        if !path.is_dir() {
+            return Err(format!("Path is not a directory: {}", path.display()));
+        }
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn open_project(
+    path: String,
+    state: &SessionState,
+    store: &dyn StoreOps,
+) -> Result<String, String> {
+    let p = PathBuf::from(&path);
+
+    validate_project_path(p.clone()).await?;
+
+    {
+        let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+        *root = Some(p);
+    }
+
+    store.set(KEY_LAST_PROJECT, json!(path));
+    store.save()?;
+
+    Ok(path)
+}
+
+pub fn close_project(state: &SessionState, store: &dyn StoreOps) -> Result<(), String> {
+    {
+        let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+        *root = None;
+    }
+
+    store.delete(KEY_LAST_PROJECT);
+    store.save()?;
+
+    Ok(())
+}
+
+pub fn get_current_project(
+    state: &SessionState,
+    store: &dyn StoreOps,
+) -> Result<Option<String>, String> {
+    {
+        let root = state.project_root.lock().map_err(|e| e.to_string())?;
+        if let Some(path) = &*root {
+            return Ok(Some(path.to_string_lossy().to_string()));
+        }
+    }
+
+    if let Some(path_str) = store
+        .get(KEY_LAST_PROJECT)
+        .as_ref()
+        .and_then(|val| val.as_str())
+    {
+        let p = PathBuf::from(path_str);
+        if p.exists() && p.is_dir() {
+            let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+            *root = Some(p);
+            return Ok(Some(path_str.to_string()));
+        }
+    }
+
+    Ok(None)
+}
+
+pub fn get_model_preference(store: &dyn StoreOps) -> Result<Option<String>, String> {
+    if let Some(model) = store
+        .get(KEY_SELECTED_MODEL)
+        .as_ref()
+        .and_then(|val| val.as_str())
+    {
+        return Ok(Some(model.to_string()));
+    }
+    Ok(None)
+}
+
+pub fn set_model_preference(model: String, store: &dyn StoreOps) -> Result<(), String> {
+    store.set(KEY_SELECTED_MODEL, json!(model));
+    store.save()?;
+    Ok(())
+}
+
+async fn read_file_impl(full_path: PathBuf) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || {
+        fs::read_to_string(&full_path).map_err(|e| format!("Failed to read file: {}", e))
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn read_file(path: String, state: &SessionState) -> Result<String, String> {
+    let full_path = resolve_path(state, &path)?;
+    read_file_impl(full_path).await
+}
+
+async fn write_file_impl(full_path: PathBuf, content: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        if let Some(parent) = full_path.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create directories: {}", e))?;
+        }
+
+        fs::write(&full_path, content).map_err(|e| format!("Failed to write file: {}", e))
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn write_file(path: String, content: String, state: &SessionState) -> Result<(), String> {
+    let full_path = resolve_path(state, &path)?;
+    write_file_impl(full_path, content).await
+}
+
+#[derive(Serialize, Debug, poem_openapi::Object)]
+pub struct FileEntry {
+    pub name: String,
+    pub kind: String,
+}
+
+async fn list_directory_impl(full_path: PathBuf) -> Result<Vec<FileEntry>, String> {
+    tokio::task::spawn_blocking(move || {
+        let entries = fs::read_dir(&full_path).map_err(|e| format!("Failed to read dir: {}", e))?;
+
+        let mut result = Vec::new();
+        for entry in entries {
+            let entry = entry.map_err(|e| e.to_string())?;
+            let ft = entry.file_type().map_err(|e| e.to_string())?;
+            let name = entry.file_name().to_string_lossy().to_string();
+
+            result.push(FileEntry {
+                name,
+                kind: if ft.is_dir() {
+                    "dir".to_string()
+                } else {
+                    "file".to_string()
+                },
+            });
+        }
+
+        result.sort_by(|a, b| match (a.kind.as_str(), b.kind.as_str()) {
+            ("dir", "file") => std::cmp::Ordering::Less,
+            ("file", "dir") => std::cmp::Ordering::Greater,
+            _ => a.name.cmp(&b.name),
+        });
+
+        Ok(result)
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn list_directory(path: String, state: &SessionState) -> Result<Vec<FileEntry>, String> {
+    let full_path = resolve_path(state, &path)?;
+    list_directory_impl(full_path).await
+}

server/src/io/mod.rs

@@ -0,0 +1,3 @@
+pub mod fs;
+pub mod search;
+pub mod shell;

server/src/io/search.rs

@@ -0,0 +1,65 @@
+use crate::state::SessionState;
+use ignore::WalkBuilder;
+use serde::Serialize;
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Serialize, Debug, poem_openapi::Object)]
+pub struct SearchResult {
+    pub path: String,
+    pub matches: usize,
+}
+
+fn get_project_root(state: &SessionState) -> Result<PathBuf, String> {
+    state.get_project_root()
+}
+
+pub async fn search_files(
+    query: String,
+    state: &SessionState,
+) -> Result<Vec<SearchResult>, String> {
+    let root = get_project_root(state)?;
+    search_files_impl(query, root).await
+}
+
+pub async fn search_files_impl(query: String, root: PathBuf) -> Result<Vec<SearchResult>, String> {
+    let root_clone = root.clone();
+
+    let results = tokio::task::spawn_blocking(move || {
+        let mut matches = Vec::new();
+        let walker = WalkBuilder::new(&root_clone).git_ignore(true).build();
+
+        for result in walker {
+            match result {
+                Ok(entry) => {
+                    if !entry.file_type().map(|ft| ft.is_file()).unwrap_or(false) {
+                        continue;
+                    }
+
+                    let path = entry.path();
+                    if let Ok(content) = fs::read_to_string(path)
+                        && content.contains(&query)
+                    {
+                        let relative = path
+                            .strip_prefix(&root_clone)
+                            .unwrap_or(path)
+                            .to_string_lossy()
+                            .to_string();
+
+                        matches.push(SearchResult {
+                            path: relative,
+                            matches: 1,
+                        });
+                    }
+                }
+                Err(err) => eprintln!("Error walking dir: {}", err),
+            }
+        }
+
+        matches
+    })
+    .await
+    .map_err(|e| format!("Search task failed: {e}"))?;
+
+    Ok(results)
+}

server/src/io/shell.rs

@@ -0,0 +1,58 @@
+use crate::state::SessionState;
+use serde::Serialize;
+use std::path::PathBuf;
+use std::process::Command;
+
+/// Helper to get the root path (cloned) without joining
+fn get_project_root(state: &SessionState) -> Result<PathBuf, String> {
+    state.get_project_root()
+}
+
+#[derive(Serialize, Debug, poem_openapi::Object)]
+pub struct CommandOutput {
+    pub stdout: String,
+    pub stderr: String,
+    pub exit_code: i32,
+}
+
+/// Execute shell command logic (pure function for testing)
+async fn exec_shell_impl(
+    command: String,
+    args: Vec<String>,
+    root: PathBuf,
+) -> Result<CommandOutput, String> {
+    // Security Allowlist
+    let allowed_commands = [
+        "git", "cargo", "npm", "yarn", "pnpm", "node", "bun", "ls", "find", "grep", "mkdir", "rm",
+        "mv", "cp", "touch", "rustc", "rustfmt",
+    ];
+
+    if !allowed_commands.contains(&command.as_str()) {
+        return Err(format!("Command '{}' is not in the allowlist.", command));
+    }
+
+    let output = tokio::task::spawn_blocking(move || {
+        Command::new(&command)
+            .args(&args)
+            .current_dir(root)
+            .output()
+    })
+    .await
+    .map_err(|e| format!("Task join error: {}", e))?
+    .map_err(|e| format!("Failed to execute command: {}", e))?;
+
+    Ok(CommandOutput {
+        stdout: String::from_utf8_lossy(&output.stdout).to_string(),
+        stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+        exit_code: output.status.code().unwrap_or(-1),
+    })
+}
+
+pub async fn exec_shell(
+    command: String,
+    args: Vec<String>,
+    state: &SessionState,
+) -> Result<CommandOutput, String> {
+    let root = get_project_root(state)?;
+    exec_shell_impl(command, args, root).await
+}