Fs MCP Server

🚀 File System Server Tool Documentation

This file system server tool offers a series of operations for managing files and directories. It supports multiple functions, including listing file contents, reading files, searching for files, editing files, and listing allowed directories.

🚀 Quick Start

Server Usage Instructions

Installation and Running

On Linux:

# First, download the executable file
wget https://example.com/fs-mcp-server_linux

# Give execution permission
chmod +x fs-mcp-server_linux

# Run the server
./fs-mcp-server_linux

On macOS:

# Download and extract
tar -xvf fs-mcp-server_macos.tar.gz

# Run the server
./fs-mcp-server_macos

On Windows:

# Download the executable file
# Double-click the file to run

Configuring Allowed Directories

Before starting the server, you need to configure the allowed directories. You can list the allowed directories using the following commands:

# List allowed directories
./fs-mcp-server_linux --list-allowed-dirs

# Add a new allowed directory
./fs-mcp-server_linux --add-allowed-dir /path/to/directory

# Remove an unnecessary directory
./fs-mcp-server_linux --remove-allowed-dir /path/to/directory

Client Integration

Usage Example Code

Here is an example of a Rust client calling the server tool:

use mcp_client::{ClientBuilder, transport::StdioTransport};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<()> {
    // Server executable file path
    let server_path = "path/to/fs-mcp-server";
    
    // Create and connect to the server
    let (transport, mut receiver) = StdioTransport::new(server_path, vec![]);
    
    let client = ClientBuilder::new("fs-client", "0.1.0")
        .with_transport(transport)
        .build()?;
    
    // Start message handling
    let client_for_handler = client.clone();
    tokio::spawn(async move {
        while let Some(message) = receiver.recv().await {
            if let Err(e) = client_for_handler.handle_message(message).await {
                eprintln!("Error handling message: {}", e);
            }
        }
    });
    
    // Initialize the client
    let init_result = client.initialize().await?;
    println!("Connected to server: {} v{}", init_result.server_info.name, init_result.server_info.version);
    
    // List all allowed directories
    let allowed_dirs_result = client.call_tool("list_allowed_dirs", &json!({})).await?;
    println!("Allowed directories: {:?}", allowed_dirs_result);
    
    // List the contents of a specified directory
    let list_dir_result = client.call_tool("list_dir", &json!({"path": "/your/directory/path"})).await?;
    println!("Directory contents: {:?}", list_dir_result);
    
    // Read file contents
    let read_file_result = client.call_tool("read_file", &json!({"file_path": "/path/to/file.txt"})).await?;
    println!("File contents: {}", String::from_utf8(read_file_result).unwrap());
    
    // Search for files
    let search_result = client.call_tool("search_files", &json!({
        "pattern": "*.txt",
        "directories": ["/path/to/search"]
    })).await?;
    println!("Search results: {:?}", search_result);
    
    // Edit file contents
    let edit_file_result = client.call_tool("edit_file", &json!({
        "file_path": "/path/to/file.txt",
        "content": "New file content"
    })).await?;
    println!("File editing completed: {}", edit_file_result);
    
    Ok(())
}

✨ Features

• Cross - platform Support: Compatible with Linux, macOS, and Windows.
• Powerful Permission Control: Ensures operation security by configuring allowed directories.
• Efficient Operation Performance: Optimizes file operation speed, suitable for handling large amounts of data.
• Flexible Configuration Options: Allows customization of behavior through command - line parameters or configuration files.

📦 Installation

Building Instructions

On Linux:

# Clone the project repository
git clone https://github.com/your-username/fs-mcp-server.git

# Enter the project directory
cd fs-mcp-server

# Build using Rust
cargo build --release

On macOS:

# Clone the project repository
git clone https://github.com/your-username/fs-mcp-server.git

# Enter the project directory
cd fs-mcp-server

# Build using Rust
cargo build --release

On Windows:

# Set Rust environment variables
# Run after cloning the project repository and entering the directory
cargo build --release

💻 Usage Examples

Basic Usage

Listing Allowed Directories

fn list_allowed_dirs() -> Vec<String> {
    // Read the configuration file to get the list of allowed directories
    let config = read_config();
    config.allowed_dirs.clone()
}

Reading File Contents

fn read_file(file_path: &str) -> Option<Vec<u8>> {
    match fs::read(file_path) {
        Ok(content) => Some(content),
        Err(e) => {
            eprintln!("Unable to read file: {}", e);
            None
        }
    }
}

Searching for Files

fn search_files(pattern: &str, directories: Vec<&str>) -> Vec<String> {
    let mut results = Vec::new();
    
    for dir in directories {
        if Path::exists(dir) && Path::is_dir(dir) {
            for entry in fs::read_dir(dir).unwrap() {
                let entry_path = entry.path().to_str().unwrap();
                if entry_path.ends_with(pattern) {
                    results.push(entry_path.to_string());
                }
            }
        }
    }
    
    results
}

Editing File Contents

fn edit_file(file_path: &str, content: String) -> bool {
    match fs::write(file_path, content) {
        Ok(_) => true,
        Err(e) => {
            eprintln!("Unable to write to file: {}", e);
            false
        }
    }
}

📚 Documentation

Project Structure

.
├── README.md               # Project description document
├── LICENSE                # License file
├── Cargo.toml              # Dependency management file for Rust project
├── src/
│   ├── main.rs            # Server entry program
│   └── lib.rs             # Core function implementation
└── scripts/               # Script directory containing various tool scripts

📄 License

This project uses the MIT license. Please check the LICENSE file for specific terms.

💡 Contribution Guide

Community contributions are welcome! If you have any questions or suggestions, please submit Issues to the GitHub repository.