magick-mcp 0.1.1

A MCP server which facilitates usage of ImageMagick.
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

use crate::mcp::server::MagickServerHandler;
use rmcp::handler::server::router::tool::ToolRoute;
use rmcp::handler::server::tool::ToolCallContext;
use rmcp::model::{CallToolResult, ErrorCode, ErrorData, Tool};
use serde_json::json;

/// Save a magick function
async fn func_save_tool(
    context: ToolCallContext<'_, MagickServerHandler>,
) -> Result<CallToolResult, ErrorData> {
    // Extract name parameter from context
    let name = context
        .arguments
        .as_ref()
        .and_then(|args| args.get("name"))
        .and_then(|v| v.as_str())
        .ok_or_else(|| ErrorData {
            code: ErrorCode::INVALID_PARAMS,
            message: "Missing required parameter: name".to_string().into(),
            data: None,
        })?;

    // Extract commands array from context
    let commands_value = context
        .arguments
        .as_ref()
        .and_then(|args| args.get("commands"))
        .ok_or_else(|| ErrorData {
            code: ErrorCode::INVALID_PARAMS,
            message: "Missing required parameter: commands".to_string().into(),
            data: None,
        })?;

    let commands: Vec<String> = commands_value
        .as_array()
        .ok_or_else(|| ErrorData {
            code: ErrorCode::INVALID_PARAMS,
            message: "Parameter 'commands' must be an array".to_string().into(),
            data: None,
        })?
        .iter()
        .map(|v| {
            v.as_str().map(|s| s.to_string()).ok_or_else(|| ErrorData {
                code: ErrorCode::INVALID_PARAMS,
                message: "All items in 'commands' array must be strings"
                    .to_string()
                    .into(),
                data: None,
            })
        })
        .collect::<Result<Vec<String>, ErrorData>>()?;

    let function = crate::Function {
        name: name.to_string(),
        commands,
    };

    match crate::save_function(function) {
        Ok(_) => {
            let result = json!({
                "success": true,
                "message": format!("Function '{}' saved successfully", name)
            });
            Ok(CallToolResult::structured(result))
        }
        Err(e) => {
            let error_result = json!({
                "error": format!("Failed to save function: {}", e),
                "success": false
            });
            Ok(CallToolResult::structured_error(error_result))
        }
    }
}

/// Create the func_save tool route
pub fn func_save_tool_route() -> ToolRoute<MagickServerHandler> {
    let input_schema: serde_json::Value = json!({
        "type": "object",
        "properties": {
            "name": {
                "type": "string",
                "description": "Name of the function to save"
            },
            "commands": {
                "type": "array",
                "items": {
                    "type": "string"
                },
                "description": "Array of ImageMagick command strings to execute in sequence. Important: Use $input to represent the input file, this will be replaced during execution. You can also use $input for output and intermediate file names."
            }
        },
        "required": ["name", "commands"]
    });
    let tool = Tool::new(
        "func_save",
        "Save a magick function with a name and array of commands",
        input_schema.as_object().unwrap().clone(),
    );
    ToolRoute::new_dyn(tool, |context| Box::pin(func_save_tool(context)))
}