mcp-tools 0.1.0

Rust MCP tools library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! MCP Tools CLI Client Binary
//!
//! Command-line interface for interacting with MCP servers
//! Provides interactive and batch modes for testing and automation

use clap::Parser;
use mcp_tools::{clients::CliClient, common::ClientConfig, Result};

/// CLI arguments for the MCP client
#[derive(Parser)]
#[command(name = "mcp-cli")]
#[command(about = "MCP Tools CLI Client")]
#[command(version = "1.0")]
pub struct CliArgs {
    /// Server URL to connect to
    #[arg(short, long, default_value = "http://localhost:8080")]
    pub server: String,

    /// Connection timeout in seconds
    #[arg(short, long, default_value = "30")]
    pub timeout: u64,

    /// Enable verbose logging
    #[arg(short, long)]
    pub verbose: bool,

    /// Output format (json, yaml, table)
    #[arg(short, long, default_value = "table")]
    pub format: String,

    /// Command to execute
    #[command(subcommand)]
    pub command: Option<CliCommand>,
}

/// CLI commands
#[derive(clap::Subcommand, Clone)]
pub enum CliCommand {
    /// Connect to MCP server and show capabilities
    Connect,

    /// List available tools
    ListTools,

    /// Execute a tool
    Execute {
        /// Tool name to execute
        tool: String,

        /// Tool arguments as JSON string
        #[arg(short, long)]
        args: Option<String>,

        /// Tool arguments as key=value pairs
        #[arg(short = 'p', long = "param")]
        params: Vec<String>,
    },

    /// Interactive mode
    Interactive,

    /// Show server status
    Status,

    /// Disconnect from server
    Disconnect,
}

#[tokio::main]
async fn main() -> Result<()> {
    // Parse command line arguments
    let args = CliArgs::parse();

    // Create client configuration
    let config = ClientConfig {
        name: "MCP-Tools-CLI".to_string(),
        version: "1.0.0".to_string(),
        server_url: args.server.clone(),
        connect_timeout_secs: 30,
        request_timeout_secs: args.timeout,
        log_requests: args.verbose,
        client_config: std::collections::HashMap::new(),
    };

    // Convert to internal CliArgs structure
    let cli_args = mcp_tools::clients::cli::CliArgs {
        server: args.server,
        timeout: args.timeout,
        verbose: args.verbose,
        format: args.format,
        command: args.command.map(|cmd| match cmd {
            CliCommand::Connect => mcp_tools::clients::cli::CliCommand::Connect,
            CliCommand::ListTools => mcp_tools::clients::cli::CliCommand::ListTools,
            CliCommand::Execute { tool, args, params } => {
                mcp_tools::clients::cli::CliCommand::Execute { tool, args, params }
            }
            CliCommand::Interactive => mcp_tools::clients::cli::CliCommand::Interactive,
            CliCommand::Status => mcp_tools::clients::cli::CliCommand::Status,
            CliCommand::Disconnect => mcp_tools::clients::cli::CliCommand::Disconnect,
        }),
    };

    // Create and run CLI client
    let mut client = CliClient::new(config, cli_args);
    client.run().await
}