refactor: modularize MCP server tools by functionality

- Split large mcp_server.go into modular files by functionality
- Create dedicated files for each tool category:
  - mcp_tools_device.go: Device management tools
  - mcp_tools_touch.go: Touch operation tools  
  - mcp_tools_swipe.go: Swipe and drag operation tools
  - mcp_tools_input.go: Input and IME tools
  - mcp_tools_button.go: Button operation tools
  - mcp_tools_app.go: Application management tools
  - mcp_tools_screen.go: Screen operation tools
  - mcp_tools_utility.go: Utility tools (sleep, popups)
  - mcp_tools_web.go: Web operation tools
  - mcp_tools_ai.go: AI-driven operation tools
- Update mcp_server.md documentation to reflect modular architecture
- Maintain pure ActionTool architecture with complete tool decoupling
- Improve code organization and maintainability

uixt/mcp_tools_device.go

@@ -0,0 +1,116 @@
+package uixt
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/danielpaulus/go-ios/ios"
+	"github.com/httprunner/httprunner/v5/internal/json"
+	"github.com/httprunner/httprunner/v5/pkg/gadb"
+	"github.com/httprunner/httprunner/v5/uixt/option"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+	"github.com/rs/zerolog/log"
+)
+
+// ToolListAvailableDevices implements the list_available_devices tool call.
+type ToolListAvailableDevices struct{}
+
+func (t *ToolListAvailableDevices) Name() option.ActionName {
+	return option.ACTION_ListAvailableDevices
+}
+
+func (t *ToolListAvailableDevices) Description() string {
+	return "List all available devices including Android devices and iOS devices. If there are multiple devices returned, you need to let the user select one of them."
+}
+
+func (t *ToolListAvailableDevices) Options() []mcp.ToolOption {
+	return []mcp.ToolOption{}
+}
+
+func (t *ToolListAvailableDevices) Implement() server.ToolHandlerFunc {
+	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		deviceList := make(map[string][]string)
+		if client, err := gadb.NewClient(); err == nil {
+			if androidDevices, err := client.DeviceList(); err == nil {
+				serialList := make([]string, 0, len(androidDevices))
+				for _, device := range androidDevices {
+					serialList = append(serialList, device.Serial())
+				}
+				deviceList["androidDevices"] = serialList
+			}
+		}
+		if iosDevices, err := ios.ListDevices(); err == nil {
+			serialList := make([]string, 0, len(iosDevices.DeviceList))
+			for _, dev := range iosDevices.DeviceList {
+				device, err := NewIOSDevice(
+					option.WithUDID(dev.Properties.SerialNumber))
+				if err != nil {
+					continue
+				}
+				properties := device.Properties
+				err = ios.Pair(dev)
+				if err != nil {
+					log.Error().Err(err).Msg("failed to pair device")
+					continue
+				}
+				serialList = append(serialList, properties.SerialNumber)
+			}
+			deviceList["iosDevices"] = serialList
+		}
+
+		jsonResult, _ := json.Marshal(deviceList)
+		return mcp.NewToolResultText(string(jsonResult)), nil
+	}
+}
+
+func (t *ToolListAvailableDevices) ConvertActionToCallToolRequest(action MobileAction) (mcp.CallToolRequest, error) {
+	return buildMCPCallToolRequest(t.Name(), map[string]any{}), nil
+}
+
+func (t *ToolListAvailableDevices) ReturnSchema() map[string]string {
+	return map[string]string{
+		"androidDevices": "[]string: List of Android device serial numbers",
+		"iosDevices":     "[]string: List of iOS device UDIDs",
+	}
+}
+
+// ToolSelectDevice implements the select_device tool call.
+type ToolSelectDevice struct{}
+
+func (t *ToolSelectDevice) Name() option.ActionName {
+	return option.ACTION_SelectDevice
+}
+
+func (t *ToolSelectDevice) Description() string {
+	return "Select a device to use from the list of available devices. Use the list_available_devices tool first to get a list of available devices."
+}
+
+func (t *ToolSelectDevice) Options() []mcp.ToolOption {
+	return []mcp.ToolOption{
+		mcp.WithString("platform", mcp.Enum("android", "ios"), mcp.Description("The platform type of device to select")),
+		mcp.WithString("serial", mcp.Description("The device serial number or UDID to select")),
+	}
+}
+
+func (t *ToolSelectDevice) Implement() server.ToolHandlerFunc {
+	return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		driverExt, err := setupXTDriver(ctx, request.Params.Arguments)
+		if err != nil {
+			return nil, err
+		}
+
+		uuid := driverExt.IDriver.GetDevice().UUID()
+		return mcp.NewToolResultText(fmt.Sprintf("Selected device: %s", uuid)), nil
+	}
+}
+
+func (t *ToolSelectDevice) ConvertActionToCallToolRequest(action MobileAction) (mcp.CallToolRequest, error) {
+	return buildMCPCallToolRequest(t.Name(), map[string]any{}), nil
+}
+
+func (t *ToolSelectDevice) ReturnSchema() map[string]string {
+	return map[string]string{
+		"message": "string: Success message with selected device UUID",
+	}
+}