transport_stdio.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/transport.h>
 
#include <atomic>
#include <chrono>
#include <map>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
#include <sys/types.h>
 
namespace entropic {
 
class StdioTransport : public Transport {
public:
    StdioTransport(
        std::string command,
        std::vector<std::string> args,
        std::map<std::string, std::string> env = {},
        uint32_t default_timeout_ms = 30000);
 
    StdioTransport(
        std::string display_name,
        std::string command,
        std::vector<std::string> args,
        std::map<std::string, std::string> env,
        uint32_t default_timeout_ms);
 
    ~StdioTransport() override;
 
    bool open() override;
 
    void close() override;
 
    std::string send_request(
        const std::string& request_json,
        uint32_t timeout_ms = 0) override;
 
    bool is_connected() const override;
 
    void interrupt() override;
 
    void clear_interrupt() override;
 
    bool request_cancelled() const;
 
    bool is_interrupted() const override;
 
    const std::string& display_name() const { return display_name_; }
 
    void set_working_dir(std::string dir) { working_dir_ = std::move(dir); }
 
private:
    std::atomic<bool> cancel_flag_{false};        
 
    std::string display_name_;                   
    std::string command_;                        
    std::vector<std::string> args_;              
    std::map<std::string, std::string> env_;     
    std::string working_dir_;                    
    uint32_t default_timeout_ms_;                
 
    pid_t child_pid_{-1};                        
    int stdin_fd_{-1};                           
    int stdout_fd_{-1};                          
    int stderr_fd_{-1};                          
    std::atomic<bool> connected_{false};         
    std::thread stderr_thread_;                  
    std::mutex io_mutex_;                        
    bool desynced_ = false;
 
    std::vector<std::string> build_env() const;
 
    bool spawn_child(int stdin_r, int stdout_w, int stderr_w,
                     const std::vector<std::string>& env_strs);
 
    static bool create_pipe(int& read_fd, int& write_fd);
 
    std::string read_line(int fd, uint32_t timeout_ms);
 
    int drain_orphaned_responses();
 
    int poll_until_ready(
        int fd,
        std::chrono::steady_clock::time_point deadline);
 
    bool create_all_pipes(int (&fds)[6]);
 
    bool open_child_process();
 
    void stderr_reader_loop();
 
    void terminate_child();
 
    static void close_fd(int& fd);
};
 
} // namespace entropic