mirror of
https://github.com/httprunner/httprunner.git
synced 2026-05-11 18:11:21 +08:00
276 lines
7.8 KiB
Go
276 lines
7.8 KiB
Go
package uixt
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/mark3labs/mcp-go/mcp"
|
|
"github.com/mark3labs/mcp-go/server"
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"github.com/httprunner/httprunner/v5/uixt/option"
|
|
)
|
|
|
|
// ToolInput implements the input tool call.
|
|
type ToolInput struct {
|
|
// Return data fields - these define the structure of data returned by this tool
|
|
Text string `json:"text" desc:"Text that was input"`
|
|
}
|
|
|
|
func (t *ToolInput) Name() option.ActionName {
|
|
return option.ACTION_Input
|
|
}
|
|
|
|
func (t *ToolInput) Description() string {
|
|
return "Input text into the currently focused element or input field"
|
|
}
|
|
|
|
func (t *ToolInput) Options() []mcp.ToolOption {
|
|
unifiedReq := &option.ActionOptions{}
|
|
return unifiedReq.GetMCPOptions(option.ACTION_Input)
|
|
}
|
|
|
|
func (t *ToolInput) Implement() server.ToolHandlerFunc {
|
|
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
|
arguments := request.GetArguments()
|
|
driverExt, err := setupXTDriver(ctx, arguments)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("setup driver failed: %w", err)
|
|
}
|
|
|
|
unifiedReq, err := parseActionOptions(arguments)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if unifiedReq.Text == "" {
|
|
return nil, fmt.Errorf("text is required")
|
|
}
|
|
|
|
opts := unifiedReq.Options()
|
|
|
|
// Input action logic
|
|
err = driverExt.Input(unifiedReq.Text, opts...)
|
|
if err != nil {
|
|
return NewMCPErrorResponse(fmt.Sprintf("Input failed: %s", err.Error())), err
|
|
}
|
|
|
|
message := fmt.Sprintf("Successfully input text: %s", unifiedReq.Text)
|
|
returnData := ToolInput{Text: unifiedReq.Text}
|
|
|
|
return NewMCPSuccessResponse(message, &returnData), nil
|
|
}
|
|
}
|
|
|
|
func (t *ToolInput) ConvertActionToCallToolRequest(action option.MobileAction) (mcp.CallToolRequest, error) {
|
|
text := fmt.Sprintf("%v", action.Params)
|
|
arguments := map[string]any{
|
|
"text": text,
|
|
}
|
|
return BuildMCPCallToolRequest(t.Name(), arguments, action), nil
|
|
}
|
|
|
|
// ToolSetIme implements the set_ime tool call.
|
|
type ToolSetIme struct {
|
|
// Return data fields - these define the structure of data returned by this tool
|
|
Ime string `json:"ime" desc:"IME that was set"`
|
|
}
|
|
|
|
func (t *ToolSetIme) Name() option.ActionName {
|
|
return option.ACTION_SetIme
|
|
}
|
|
|
|
func (t *ToolSetIme) Description() string {
|
|
return "Set the input method editor (IME) on the device"
|
|
}
|
|
|
|
func (t *ToolSetIme) Options() []mcp.ToolOption {
|
|
unifiedReq := &option.ActionOptions{}
|
|
return unifiedReq.GetMCPOptions(option.ACTION_SetIme)
|
|
}
|
|
|
|
func (t *ToolSetIme) Implement() server.ToolHandlerFunc {
|
|
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
|
arguments := request.GetArguments()
|
|
driverExt, err := setupXTDriver(ctx, arguments)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("setup driver failed: %w", err)
|
|
}
|
|
|
|
unifiedReq, err := parseActionOptions(arguments)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Set IME action logic
|
|
err = driverExt.SetIme(unifiedReq.Ime)
|
|
if err != nil {
|
|
return NewMCPErrorResponse(fmt.Sprintf("Set IME failed: %s", err.Error())), err
|
|
}
|
|
|
|
message := fmt.Sprintf("Successfully set IME to: %s", unifiedReq.Ime)
|
|
returnData := ToolSetIme{Ime: unifiedReq.Ime}
|
|
|
|
return NewMCPSuccessResponse(message, &returnData), nil
|
|
}
|
|
}
|
|
|
|
func (t *ToolSetIme) ConvertActionToCallToolRequest(action option.MobileAction) (mcp.CallToolRequest, error) {
|
|
if ime, ok := action.Params.(string); ok {
|
|
arguments := map[string]any{
|
|
"ime": ime,
|
|
}
|
|
return BuildMCPCallToolRequest(t.Name(), arguments, action), nil
|
|
}
|
|
return mcp.CallToolRequest{}, fmt.Errorf("invalid set ime params: %v", action.Params)
|
|
}
|
|
|
|
// ToolBackspace implements the backspace tool call.
|
|
type ToolBackspace struct {
|
|
// Return data fields - these define the structure of data returned by this tool
|
|
Count int `json:"count" desc:"Number of backspace operations performed"`
|
|
}
|
|
|
|
func (t *ToolBackspace) Name() option.ActionName {
|
|
return option.ACTION_Backspace
|
|
}
|
|
|
|
func (t *ToolBackspace) Description() string {
|
|
return "Perform backspace operations to delete characters"
|
|
}
|
|
|
|
func (t *ToolBackspace) Options() []mcp.ToolOption {
|
|
unifiedReq := &option.ActionOptions{}
|
|
return unifiedReq.GetMCPOptions(option.ACTION_Backspace)
|
|
}
|
|
|
|
func (t *ToolBackspace) Implement() server.ToolHandlerFunc {
|
|
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
|
arguments := request.GetArguments()
|
|
driverExt, err := setupXTDriver(ctx, arguments)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("setup driver failed: %w", err)
|
|
}
|
|
|
|
unifiedReq, err := parseActionOptions(arguments)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
count := unifiedReq.Count
|
|
if count <= 0 {
|
|
count = 1 // Default to 1 backspace if not specified or invalid
|
|
}
|
|
|
|
opts := unifiedReq.Options()
|
|
|
|
// Backspace action logic
|
|
err = driverExt.Backspace(count, opts...)
|
|
if err != nil {
|
|
return NewMCPErrorResponse(fmt.Sprintf("Backspace failed: %s", err.Error())), err
|
|
}
|
|
|
|
message := fmt.Sprintf("Successfully performed %d backspace operations", count)
|
|
returnData := ToolBackspace{Count: count}
|
|
|
|
return NewMCPSuccessResponse(message, &returnData), nil
|
|
}
|
|
}
|
|
|
|
func (t *ToolBackspace) ConvertActionToCallToolRequest(action option.MobileAction) (mcp.CallToolRequest, error) {
|
|
var count int
|
|
switch v := action.Params.(type) {
|
|
case int:
|
|
count = v
|
|
case float64:
|
|
count = int(v)
|
|
default:
|
|
count = 1 // Default count
|
|
}
|
|
|
|
arguments := map[string]any{
|
|
"count": count,
|
|
}
|
|
return BuildMCPCallToolRequest(t.Name(), arguments, action), nil
|
|
}
|
|
|
|
// ToolSIMInput implements the sim_input tool call.
|
|
type ToolSIMInput struct {
|
|
// Return data fields - these define the structure of data returned by this tool
|
|
Text string `json:"text" desc:"Text that was input with simulation"`
|
|
Segments int `json:"segments" desc:"Number of segments the text was split into"`
|
|
}
|
|
|
|
func (t *ToolSIMInput) Name() option.ActionName {
|
|
return option.ACTION_SIMInput
|
|
}
|
|
|
|
func (t *ToolSIMInput) Description() string {
|
|
return "Input text with intelligent segmentation and human-like typing patterns"
|
|
}
|
|
|
|
func (t *ToolSIMInput) Options() []mcp.ToolOption {
|
|
unifiedReq := &option.ActionOptions{}
|
|
return unifiedReq.GetMCPOptions(option.ACTION_SIMInput)
|
|
}
|
|
|
|
func (t *ToolSIMInput) Implement() server.ToolHandlerFunc {
|
|
return func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
|
|
arguments := request.GetArguments()
|
|
driverExt, err := setupXTDriver(ctx, arguments)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("setup driver failed: %w", err)
|
|
}
|
|
|
|
unifiedReq, err := parseActionOptions(arguments)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if unifiedReq.Text == "" {
|
|
return nil, fmt.Errorf("text is required")
|
|
}
|
|
|
|
text := unifiedReq.Text
|
|
|
|
log.Info().
|
|
Str("text", text).
|
|
Int("textLength", len(text)).
|
|
Msg("performing simulated input")
|
|
|
|
opts := unifiedReq.Options()
|
|
|
|
// Call the underlying SIMInput method (check if driver supports SIM)
|
|
if simDriver, ok := driverExt.IDriver.(SIMSupport); ok {
|
|
err = simDriver.SIMInput(text, opts...)
|
|
if err != nil {
|
|
return NewMCPErrorResponse(fmt.Sprintf("Simulated input failed: %s", err.Error())), err
|
|
}
|
|
} else {
|
|
return NewMCPErrorResponse("SIMInput is not supported by the current driver"), fmt.Errorf("driver does not implement SIMSupport interface")
|
|
}
|
|
|
|
// Estimate segments count (this is approximate since the actual segmentation happens in the driver)
|
|
estimatedSegments := len([]rune(text))/2 + 1
|
|
if estimatedSegments < 1 {
|
|
estimatedSegments = 1
|
|
}
|
|
|
|
message := fmt.Sprintf("Successfully performed simulated input: %s", text)
|
|
returnData := ToolSIMInput{
|
|
Text: text,
|
|
Segments: estimatedSegments,
|
|
}
|
|
|
|
return NewMCPSuccessResponse(message, &returnData), nil
|
|
}
|
|
}
|
|
|
|
func (t *ToolSIMInput) ConvertActionToCallToolRequest(action option.MobileAction) (mcp.CallToolRequest, error) {
|
|
text := fmt.Sprintf("%v", action.Params)
|
|
arguments := map[string]any{
|
|
"text": text,
|
|
}
|
|
return BuildMCPCallToolRequest(t.Name(), arguments, action), nil
|
|
}
|