filesystem.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/server_base.h>
#include <entropic/mcp/servers/ignore_matcher.h>
#include <entropic/mcp/session_scoped.h>
#include <entropic/types/config.h>
 
#include <filesystem>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic {
 
class FileAccessTracker {
public:
    void record_read(const std::string& session, const std::string& path,
                     size_t hash);
 
    bool was_read(const std::string& session, const std::string& path) const;
 
    bool release_session(const std::string& session);
 
    std::size_t session_count() const;
 
private:
    SessionScoped<std::unordered_map<std::string, size_t>> reads_;
};
 
enum class PathAccess {
    read,   
    write,  
};
 
struct OutsideRootRequest {
    std::string path;   
    std::string root;   
    std::string tool;   
    PathAccess access = PathAccess::read; 
};
 
enum class OutsideRootVerdict {
    approved,     
    rejected,     
    no_approver,  
};
 
using OutsideRootApprover = OutsideRootVerdict (*)(
    const OutsideRootRequest& request, void* user_data);
 
// Forward declarations for tool classes
class ReadFileTool;
class WriteFileTool;
class EditFileTool;
class GlobTool;
class GrepTool;
class ListDirectoryTool;
 
class FilesystemServer : public MCPServerBase, public SessionStateOwner {
public:
    FilesystemServer(const std::filesystem::path& root_dir,
                     const FilesystemConfig& config,
                     const std::string& data_dir,
                     int model_context_bytes = 0);
 
    ~FilesystemServer() override;
 
    bool skip_duplicate_check(const std::string& tool_name) const override;
 
    bool set_working_dir(const std::string& path) override;
 
    const std::filesystem::path& root_dir() const;
 
    FileAccessTracker& tracker();
 
    bool release_session(const std::string& key) override;
 
    std::size_t session_count() const override;
 
    const FilesystemConfig& config() const;
 
    int max_read_bytes() const;
 
    std::filesystem::path resolve_path(const std::string& requested,
                                       PathAccess access,
                                       const std::string& tool) const;
 
    void set_outside_root_approver(OutsideRootApprover fn, void* user_data);
 
    const IgnoreMatcher& ignore() const;
 
private:
    void create_fs_tools(const std::string& data_dir);
 
    void register_fs_tools();
 
    void authorize_outside_root(const std::filesystem::path& resolved,
                                PathAccess access,
                                const std::string& tool) const;
 
    void ask_outside_root_approver(const std::filesystem::path& resolved,
                                   PathAccess access,
                                   const std::string& tool) const;
 
    void log_outside_root_policy() const;
 
    std::filesystem::path root_dir_;  
    FilesystemConfig config_;         
    int max_read_bytes_ = 0;          
    FileAccessTracker tracker_;       
    IgnoreMatcher ignore_;            
 
    mutable std::mutex approver_mutex_;
    OutsideRootApprover approver_ = nullptr; 
    void* approver_data_ = nullptr;          
 
    // Owned tool instances
    std::unique_ptr<ReadFileTool> read_file_;
    std::unique_ptr<WriteFileTool> write_file_;
    std::unique_ptr<EditFileTool> edit_file_;
    std::unique_ptr<GlobTool> glob_;
    std::unique_ptr<GrepTool> grep_;
    std::unique_ptr<ListDirectoryTool> list_dir_;
};
 
} // namespace entropic