Simulate Input in Chrome

interface SimulateInputRequest {
  selector: string;
  text: string;
}

interface ActionResponse {
  success: boolean;
  message: string;
  timestamp: string;
}

/**
 * Simulates user input in Chrome by typing text into an element specified by a CSS selector.
 * 
 * @param selector - CSS selector to identify the target input element
 * @param text - The text to type into the specified input element
 * @param apiKey - Your API key for authentication
 * @returns A promise that resolves to the action response
 */
async function simulateInputInChrome(
  selector: string,
  text: string,
  apiKey: string
): Promise {
  const url = 'http://localhost:5000/tools-api/chrome/simulate-input';
  
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  };
  
  const requestBody: SimulateInputRequest = {
    selector,
    text
  };
  
  const response = await fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(requestBody)
  });
  
  return await response.json();
}

// Example usage
(async () => {
  const API_KEY = 'your_api_key_here';
  
  try {
    // Example: Type a search query in a search box
    const result = await simulateInputInChrome(
      '#search-input',
      'Smooth Operator documentation',
      API_KEY
    );
    
    console.log(`Success: ${result.success}`);
    console.log(`Message: ${result.message}`);
  } catch (error) {
    console.error('Error simulating input:', error);
  }
})();
                    

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class SimulateInputRequest
{
    public string Selector { get; set; }
    public string Text { get; set; }
}

public class ActionResponse
{
    public bool Success { get; set; }
    public string Message { get; set; }
    public DateTime Timestamp { get; set; }
}

public class ToolsServerClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    
    public ToolsServerClient(string apiKey)
    {
        _httpClient = new HttpClient();
        _httpClient.BaseAddress = new Uri("http://localhost:5000/");
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
        _apiKey = apiKey;
    }
    
    /// 

    /// Simulates user input in Chrome by typing text into an element specified by a CSS selector.
    /// 
    /// CSS selector to identify the target input element
    /// The text to type into the specified input element
    /// Response indicating success or failure of the operation
    public async Task SimulateInputInChromeAsync(string selector, string text)
    {
        var request = new SimulateInputRequest
        {
            Selector = selector,
            Text = text
        };
        
        var jsonContent = JsonSerializer.Serialize(request);
        var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync("tools-api/chrome/simulate-input", content);
        var responseBody = await response.Content.ReadAsStringAsync();
        
        return JsonSerializer.Deserialize(responseBody, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        });
    }
}

// Example usage
class Program
{
    static async Task Main(string[] args)
    {
        string apiKey = "your_api_key_here";
        var client = new ToolsServerClient(apiKey);
        
        try
        {
            // Example: Type a search query in a search box
            var result = await client.SimulateInputInChromeAsync(
                "#search-input", 
                "Smooth Operator documentation"
            );
            
            Console.WriteLine($"Success: {result.Success}");
            Console.WriteLine($"Message: {result.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}