2003 lines
78 KiB
C#
2003 lines
78 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Timers;
|
|
using System.Windows;
|
|
using System.Windows.Threading;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using CtrEditor.ObjetosSim;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using System.IO;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Windows.Media;
|
|
using System.Windows.Shapes;
|
|
using System.Windows.Controls;
|
|
using CtrEditor.FuncionesBase;
|
|
using CtrEditor.HydraulicSimulator.Python;
|
|
|
|
namespace CtrEditor.Services
|
|
{
|
|
/// <summary>
|
|
/// Representa una entrada de log con timestamp
|
|
/// </summary>
|
|
public class DebugLogEntry
|
|
{
|
|
public DateTime Timestamp { get; set; }
|
|
public string Message { get; set; }
|
|
public string Level { get; set; }
|
|
|
|
public DebugLogEntry(string message, string level = "Info")
|
|
{
|
|
Timestamp = DateTime.Now;
|
|
Message = message ?? string.Empty;
|
|
Level = level;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"[{Timestamp:yyyy-MM-dd HH:mm:ss.fff}] [{Level}] {Message}";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Servidor MCP TCP para CtrEditor que permite control remoto de la aplicación
|
|
/// para debugging y testing usando el protocolo Model Context Protocol
|
|
/// </summary>
|
|
public class MCPServer : IDisposable
|
|
{
|
|
private readonly MainViewModel _mainViewModel;
|
|
private readonly int _port;
|
|
private TcpListener _tcpListener;
|
|
private CancellationTokenSource _cancellationTokenSource;
|
|
private bool _isRunning;
|
|
private readonly object _lockObject = new object();
|
|
private ScreenshotManager _screenshotManager;
|
|
|
|
// Simulation timing tracking
|
|
private readonly Stopwatch _simulationStopwatch;
|
|
private long _totalSimulationMilliseconds;
|
|
private bool _lastSimulationStatus;
|
|
|
|
// Circular debug log system
|
|
private readonly ConcurrentQueue<DebugLogEntry> _debugLogBuffer;
|
|
private readonly object _logLock = new object();
|
|
private readonly System.Timers.Timer _logCleanupTimer;
|
|
private const int MAX_LOG_ENTRIES = 1000;
|
|
private volatile int _currentLogCount = 0;
|
|
|
|
public MCPServer(MainViewModel mainViewModel, int port = 5006)
|
|
{
|
|
_mainViewModel = mainViewModel ?? throw new ArgumentNullException(nameof(mainViewModel));
|
|
_port = port;
|
|
_cancellationTokenSource = new CancellationTokenSource();
|
|
|
|
// Initialize simulation timing
|
|
_simulationStopwatch = new Stopwatch();
|
|
_totalSimulationMilliseconds = 0;
|
|
_lastSimulationStatus = false;
|
|
|
|
// Initialize circular debug log system
|
|
_debugLogBuffer = new ConcurrentQueue<DebugLogEntry>();
|
|
_logCleanupTimer = new System.Timers.Timer(1000); // 1 second interval
|
|
_logCleanupTimer.Elapsed += CleanupLogBuffer;
|
|
_logCleanupTimer.AutoReset = true;
|
|
_logCleanupTimer.Start();
|
|
|
|
// Subscribe to debug output from the start
|
|
Trace.Listeners.Add(new DebugTraceListener(this));
|
|
|
|
// ScreenshotManager se inicializará de forma lazy cuando se necesite
|
|
_screenshotManager = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtiene el ScreenshotManager, inicializándolo si es necesario
|
|
/// </summary>
|
|
private ScreenshotManager GetScreenshotManager()
|
|
{
|
|
if (_screenshotManager == null)
|
|
{
|
|
var canvas = _mainViewModel?.MainCanvas;
|
|
if (canvas == null)
|
|
{
|
|
throw new InvalidOperationException("Canvas no está disponible. Asegúrate de que la UI esté completamente cargada.");
|
|
}
|
|
_screenshotManager = new ScreenshotManager(_mainViewModel, canvas);
|
|
}
|
|
return _screenshotManager;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inicia el servidor MCP TCP
|
|
/// </summary>
|
|
public async Task StartAsync()
|
|
{
|
|
if (_isRunning) return;
|
|
|
|
try
|
|
{
|
|
_tcpListener = new TcpListener(IPAddress.Loopback, _port);
|
|
_tcpListener.Start();
|
|
_isRunning = true;
|
|
|
|
Debug.WriteLine($"[MCP Server] Servidor iniciado en puerto {_port}");
|
|
AddDebugLogEntry($"[MCP Server] Servidor iniciado en puerto {_port}");
|
|
|
|
// Procesar conexiones en background
|
|
_ = Task.Run(async () => await AcceptConnectionsAsync(_cancellationTokenSource.Token));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error al iniciar servidor: {ex.Message}");
|
|
AddDebugLogEntry($"[MCP Server] Error al iniciar servidor: {ex.Message}", "Error");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detiene el servidor MCP TCP
|
|
/// </summary>
|
|
public void Stop()
|
|
{
|
|
if (!_isRunning) return;
|
|
|
|
lock (_lockObject)
|
|
{
|
|
if (!_isRunning) return;
|
|
|
|
_isRunning = false;
|
|
_cancellationTokenSource?.Cancel();
|
|
_tcpListener?.Stop();
|
|
|
|
Debug.WriteLine("[MCP Server] Servidor detenido");
|
|
AddDebugLogEntry("[MCP Server] Servidor detenido");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica si el dispatcher está disponible sin bloquear
|
|
/// </summary>
|
|
private bool IsDispatcherAvailable()
|
|
{
|
|
try
|
|
{
|
|
return Application.Current != null && Application.Current.Dispatcher != null && !Application.Current.Dispatcher.HasShutdownStarted;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ejecuta una acción en el dispatcher de forma segura con timeout
|
|
/// </summary>
|
|
private async Task<T> SafeDispatcherInvokeAsync<T>(Func<T> action, int timeoutMs = 5000)
|
|
{
|
|
if (!IsDispatcherAvailable())
|
|
{
|
|
throw new InvalidOperationException("Dispatcher no está disponible");
|
|
}
|
|
|
|
try
|
|
{
|
|
var task = Application.Current.Dispatcher.InvokeAsync(action);
|
|
return await task.Task.ConfigureAwait(false);
|
|
}
|
|
catch (TaskCanceledException)
|
|
{
|
|
throw new TimeoutException($"Operación en dispatcher excedió timeout de {timeoutMs}ms");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Acepta conexiones TCP entrantes
|
|
/// </summary>
|
|
private async Task AcceptConnectionsAsync(CancellationToken cancellationToken)
|
|
{
|
|
while (_isRunning && !cancellationToken.IsCancellationRequested)
|
|
{
|
|
try
|
|
{
|
|
var tcpClient = await _tcpListener.AcceptTcpClientAsync();
|
|
Debug.WriteLine("[MCP Server] Nueva conexión aceptada");
|
|
|
|
// Manejar cliente en tarea separada
|
|
_ = Task.Run(async () => await HandleClientAsync(tcpClient, cancellationToken));
|
|
}
|
|
catch (ObjectDisposedException)
|
|
{
|
|
// Expected when stopping the server
|
|
break;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (_isRunning)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error aceptando conexión: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maneja un cliente TCP individual
|
|
/// </summary>
|
|
private async Task HandleClientAsync(TcpClient tcpClient, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
using (tcpClient)
|
|
using (var stream = tcpClient.GetStream())
|
|
using (var reader = new StreamReader(stream, Encoding.UTF8))
|
|
using (var writer = new StreamWriter(stream, Encoding.UTF8) { AutoFlush = true })
|
|
{
|
|
Debug.WriteLine("[MCP Server] Cliente conectado");
|
|
|
|
// No enviar capabilities automáticamente - esperar initialize
|
|
// await SendInitialCapabilitiesAsync(writer);
|
|
|
|
string line;
|
|
while ((line = await reader.ReadLineAsync()) != null && !cancellationToken.IsCancellationRequested)
|
|
{
|
|
try
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(line))
|
|
{
|
|
var response = await ProcessRequestAsync(line);
|
|
await writer.WriteLineAsync(response);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error procesando solicitud: {ex.Message}");
|
|
var errorResponse = CreateErrorResponse(null, -32603, "Internal error", ex.Message);
|
|
await writer.WriteLineAsync(errorResponse);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error en cliente: {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
Debug.WriteLine("[MCP Server] Cliente desconectado");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Envía las capabilities iniciales del servidor MCP
|
|
/// </summary>
|
|
private async Task SendInitialCapabilitiesAsync(StreamWriter writer)
|
|
{
|
|
var capabilities = new
|
|
{
|
|
jsonrpc = "2.0",
|
|
id = "init",
|
|
result = new
|
|
{
|
|
protocolVersion = "2024-11-05",
|
|
capabilities = new
|
|
{
|
|
tools = new object[]
|
|
{
|
|
new { name = "list_objects", description = "List all objects in the simulation with metadata" },
|
|
new { name = "create_object", description = "Create a new object by type at specified position" },
|
|
new { name = "update_object", description = "Update object properties by ID using JSON" },
|
|
new { name = "delete_objects", description = "Delete objects by ID (single or batch)" },
|
|
new { name = "list_object_types", description = "List all available object types that can be created" },
|
|
new { name = "start_simulation", description = "Start the physics simulation" },
|
|
new { name = "stop_simulation", description = "Stop the physics simulation" },
|
|
new { name = "get_simulation_status", description = "Get current simulation status" },
|
|
new { name = "get_plc_status", description = "Get PLC connection status" },
|
|
new { name = "take_screenshot", description = "Take a screenshot of the canvas" },
|
|
new { name = "take_object_screenshot", description = "Take a screenshot of specific objects by their IDs" },
|
|
new { name = "save_project", description = "Save the current project" },
|
|
new { name = "reset_simulation_timing", description = "Reset simulation timing counters" },
|
|
new { name = "search_debug_log", description = "Search debug log entries with pattern matching" },
|
|
new { name = "get_debug_stats", description = "Get debug log buffer statistics" },
|
|
new { name = "clear_debug_buffer", description = "Clear the debug log buffer" },
|
|
new { name = "execute_python", description = "Execute Python code with access to CtrEditor objects" },
|
|
new { name = "python_help", description = "Get help about available Python objects and methods" }
|
|
}
|
|
},
|
|
serverInfo = new
|
|
{
|
|
name = "CtrEditor MCP Server",
|
|
version = "1.0.0",
|
|
description = "CtrEditor WPF Application MCP Server for debugging and testing"
|
|
}
|
|
}
|
|
};
|
|
|
|
var json = JsonConvert.SerializeObject(capabilities);
|
|
await writer.WriteLineAsync(json);
|
|
Debug.WriteLine("[MCP Server] Capabilities enviadas");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Procesa una solicitud JSON-RPC
|
|
/// </summary>
|
|
private async Task<string> ProcessRequestAsync(string requestJson)
|
|
{
|
|
try
|
|
{
|
|
var request = JsonConvert.DeserializeObject<JObject>(requestJson);
|
|
var method = request["method"]?.ToString();
|
|
var id = request["id"];
|
|
var parameters = request["params"] as JObject;
|
|
|
|
Debug.WriteLine($"[MCP Server] Procesando método: {method}");
|
|
|
|
return method switch
|
|
{
|
|
"initialize" => HandleInitializeAsync(id, parameters),
|
|
"tools/list" => HandleToolsListAsync(id),
|
|
"tools/call" => await HandleToolCallAsync(id, parameters),
|
|
_ => CreateErrorResponse(id, -32601, "Method not found", $"Unknown method: {method}")
|
|
};
|
|
}
|
|
catch (JsonException ex)
|
|
{
|
|
return CreateErrorResponse(null, -32700, "Parse error", ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return CreateErrorResponse(null, -32603, "Internal error", ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maneja la solicitud initialize
|
|
/// </summary>
|
|
private string HandleInitializeAsync(JToken id, JObject parameters)
|
|
{
|
|
var result = new
|
|
{
|
|
protocolVersion = "2024-11-05",
|
|
capabilities = new
|
|
{
|
|
tools = new { },
|
|
resources = new { },
|
|
prompts = new { }
|
|
},
|
|
serverInfo = new
|
|
{
|
|
name = "CtrEditor MCP Server",
|
|
version = "1.0.0"
|
|
}
|
|
};
|
|
|
|
return CreateSuccessResponse(id, result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maneja la solicitud tools/list
|
|
/// </summary>
|
|
private string HandleToolsListAsync(JToken id)
|
|
{
|
|
var tools = new object[]
|
|
{
|
|
new {
|
|
name = "list_objects",
|
|
description = "List all objects in the simulation",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
},
|
|
new {
|
|
name = "create_object",
|
|
description = "Create a new object by type at specified position",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
type = new { type = "string", description = "Object type to create" },
|
|
x = new { type = "number", description = "X position" },
|
|
y = new { type = "number", description = "Y position" }
|
|
},
|
|
required = new[] { "type", "x", "y" }
|
|
}
|
|
},
|
|
new {
|
|
name = "take_screenshot",
|
|
description = "Take a screenshot of the canvas. By default captures full canvas without background image and saves to screenshots subdirectory.",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
filename = new {
|
|
type = "string",
|
|
description = "Optional filename for the screenshot (will be saved in screenshots subdirectory). Defaults to timestamp-based name."
|
|
},
|
|
include_background = new {
|
|
type = "boolean",
|
|
description = "Whether to include canvas background image. Defaults to false (white background)."
|
|
},
|
|
x = new {
|
|
type = "number",
|
|
description = "X coordinate in meters for partial capture (optional)"
|
|
},
|
|
y = new {
|
|
type = "number",
|
|
description = "Y coordinate in meters for partial capture (optional)"
|
|
},
|
|
width = new {
|
|
type = "number",
|
|
description = "Width in meters for partial capture (optional)"
|
|
},
|
|
height = new {
|
|
type = "number",
|
|
description = "Height in meters for partial capture (optional)"
|
|
},
|
|
center_coordinates = new {
|
|
type = "boolean",
|
|
description = "If true, x and y parameters represent the center of the capture area instead of top-left corner. Defaults to false for backward compatibility."
|
|
}
|
|
}
|
|
}
|
|
},
|
|
new {
|
|
name = "take_object_screenshot",
|
|
description = "Take a screenshot of specific objects by their IDs. This automatically calculates the bounding box of the specified objects and captures only that area with optional padding.",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
object_ids = new {
|
|
type = "array",
|
|
items = new { type = "string" },
|
|
description = "Array of object IDs to capture. Can be a single object or multiple objects."
|
|
},
|
|
padding_meters = new {
|
|
type = "number",
|
|
description = "Additional padding around objects in meters. Defaults to 0.5 meters."
|
|
},
|
|
filename = new {
|
|
type = "string",
|
|
description = "Optional filename for the screenshot. Defaults to timestamp-based name."
|
|
},
|
|
include_background = new {
|
|
type = "boolean",
|
|
description = "Whether to include canvas background image. Defaults to false."
|
|
}
|
|
},
|
|
required = new[] { "object_ids" }
|
|
}
|
|
},
|
|
new {
|
|
name = "start_simulation",
|
|
description = "Start the physics simulation",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
},
|
|
new {
|
|
name = "stop_simulation",
|
|
description = "Stop the physics simulation",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
},
|
|
new {
|
|
name = "reset_simulation_timing",
|
|
description = "Reset simulation timing counters to zero",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
},
|
|
new {
|
|
name = "execute_python",
|
|
description = "Execute Python code with access to CtrEditor objects and canvas for debugging",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
code = new {
|
|
type = "string",
|
|
description = "Python code to execute. Has access to 'app' (MainViewModel), 'canvas', 'objects' (simulable objects), and common libraries."
|
|
},
|
|
return_variables = new {
|
|
type = "array",
|
|
items = new { type = "string" },
|
|
description = "Optional list of variable names to return from Python execution"
|
|
},
|
|
timeout_seconds = new {
|
|
type = "number",
|
|
description = "Execution timeout in seconds. Defaults to 30."
|
|
}
|
|
},
|
|
required = new[] { "code" }
|
|
}
|
|
},
|
|
new {
|
|
name = "python_help",
|
|
description = "Get help about available Python objects and methods in CtrEditor context",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
object_name = new {
|
|
type = "string",
|
|
description = "Optional specific object to get help for (e.g., 'app', 'canvas', 'objects')"
|
|
}
|
|
}
|
|
}
|
|
},
|
|
new {
|
|
name = "search_debug_log",
|
|
description = "Search debug log entries with pattern matching (regex or text)",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new {
|
|
pattern = new {
|
|
type = "string",
|
|
description = "Search pattern (regex or plain text). Empty returns recent entries."
|
|
},
|
|
max_lines = new {
|
|
type = "number",
|
|
description = "Maximum number of matching lines to return. Defaults to 100."
|
|
},
|
|
last_n_lines = new {
|
|
type = "number",
|
|
description = "Search only in the last N log entries. Defaults to 1000."
|
|
},
|
|
case_sensitive = new {
|
|
type = "boolean",
|
|
description = "Whether search should be case sensitive. Defaults to false."
|
|
}
|
|
}
|
|
}
|
|
},
|
|
new {
|
|
name = "get_debug_stats",
|
|
description = "Get debug log buffer statistics and status",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
},
|
|
new {
|
|
name = "clear_debug_buffer",
|
|
description = "Clear the debug log buffer",
|
|
inputSchema = new {
|
|
type = "object",
|
|
properties = new { }
|
|
}
|
|
}
|
|
};
|
|
|
|
return CreateSuccessResponse(id, new { tools });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Crea una respuesta de éxito
|
|
/// </summary>
|
|
private string CreateSuccessResponse(JToken id, object result)
|
|
{
|
|
var response = new
|
|
{
|
|
jsonrpc = "2.0",
|
|
id = id,
|
|
result = result
|
|
};
|
|
return JsonConvert.SerializeObject(response);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Maneja llamadas a herramientas (tools/call)
|
|
/// </summary>
|
|
private async Task<string> HandleToolCallAsync(JToken id, JObject parameters)
|
|
{
|
|
try
|
|
{
|
|
var toolName = parameters?["name"]?.ToString();
|
|
var arguments = parameters?["arguments"] as JObject ?? new JObject();
|
|
|
|
Debug.WriteLine($"[MCP Server] Ejecutando herramienta: {toolName}");
|
|
AddDebugLogEntry($"[MCP Server] Ejecutando herramienta: {toolName}");
|
|
|
|
object result;
|
|
|
|
// Handle async tools that need special execution context
|
|
if (toolName == "execute_python")
|
|
{
|
|
result = await ExecutePythonAsync(arguments);
|
|
}
|
|
else
|
|
{
|
|
// Use Dispatcher.InvokeAsync with timeout to prevent freezing
|
|
try
|
|
{
|
|
var task = Application.Current.Dispatcher.InvokeAsync(() => ExecuteToolAsync(toolName, arguments));
|
|
result = await task.Task.ConfigureAwait(false);
|
|
}
|
|
catch (TaskCanceledException)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Timeout ejecutando herramienta: {toolName}", "Warning");
|
|
result = new { success = false, error = "Operation timed out", tool = toolName };
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error ejecutando herramienta {toolName}: {ex.Message}", "Error");
|
|
result = new { success = false, error = ex.Message, tool = toolName };
|
|
}
|
|
}
|
|
|
|
// Envolver el resultado en el formato MCP correcto
|
|
var mcpResult = new
|
|
{
|
|
content = new[]
|
|
{
|
|
new
|
|
{
|
|
type = "text",
|
|
text = JsonConvert.SerializeObject(result, Formatting.Indented)
|
|
}
|
|
}
|
|
};
|
|
|
|
return CreateSuccessResponse(id, mcpResult);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error ejecutando herramienta: {ex.Message}");
|
|
return CreateErrorResponse(id, -32603, "Tool execution error", ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ejecuta una herramienta específica (debe ejecutarse en UI thread)
|
|
/// </summary>
|
|
private object ExecuteToolAsync(string toolName, JObject arguments)
|
|
{
|
|
switch (toolName)
|
|
{
|
|
case "list_objects":
|
|
return ListObjects();
|
|
case "create_object":
|
|
return CreateObject(arguments);
|
|
case "update_object":
|
|
return UpdateObject(arguments);
|
|
case "delete_objects":
|
|
return DeleteObjects(arguments);
|
|
case "list_object_types":
|
|
return ListObjectTypes();
|
|
case "start_simulation":
|
|
return StartSimulation(arguments);
|
|
case "stop_simulation":
|
|
return StopSimulation();
|
|
case "get_simulation_status":
|
|
return GetSimulationStatus();
|
|
case "get_plc_status":
|
|
return GetPlcStatus();
|
|
case "take_screenshot":
|
|
return TakeScreenshot(arguments);
|
|
case "take_object_screenshot":
|
|
return TakeObjectScreenshot(arguments);
|
|
case "save_project":
|
|
return SaveProject();
|
|
case "reset_simulation_timing":
|
|
return ResetSimulationTiming();
|
|
case "python_help":
|
|
return GetPythonHelp(arguments);
|
|
case "search_debug_log":
|
|
return SearchDebugLog(arguments);
|
|
case "get_debug_stats":
|
|
return GetDebugStats();
|
|
case "clear_debug_buffer":
|
|
return ClearDebugBuffer();
|
|
default:
|
|
throw new ArgumentException($"Unknown tool: {toolName}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates simulation timing based on current status
|
|
/// </summary>
|
|
private void UpdateSimulationTiming()
|
|
{
|
|
var currentSimulationStatus = _mainViewModel.IsSimulationRunning;
|
|
|
|
if (_lastSimulationStatus != currentSimulationStatus)
|
|
{
|
|
if (currentSimulationStatus)
|
|
{
|
|
// Simulation just started
|
|
Debug.WriteLine("[MCP Server] Simulation started - starting timer");
|
|
_simulationStopwatch.Start();
|
|
}
|
|
else
|
|
{
|
|
// Simulation just stopped
|
|
if (_simulationStopwatch.IsRunning)
|
|
{
|
|
_simulationStopwatch.Stop();
|
|
_totalSimulationMilliseconds += _simulationStopwatch.ElapsedMilliseconds;
|
|
Debug.WriteLine($"[MCP Server] Simulation stopped - total time: {_totalSimulationMilliseconds}ms");
|
|
_simulationStopwatch.Reset();
|
|
}
|
|
}
|
|
_lastSimulationStatus = currentSimulationStatus;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets current simulation elapsed time in milliseconds
|
|
/// </summary>
|
|
private long GetCurrentSimulationMilliseconds()
|
|
{
|
|
UpdateSimulationTiming();
|
|
|
|
var currentElapsed = _simulationStopwatch.IsRunning ? _simulationStopwatch.ElapsedMilliseconds : 0;
|
|
return _totalSimulationMilliseconds + currentElapsed;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets simulation timing counters
|
|
/// </summary>
|
|
private object ResetSimulationTiming()
|
|
{
|
|
try
|
|
{
|
|
var wasRunning = _simulationStopwatch.IsRunning;
|
|
var previousTotal = _totalSimulationMilliseconds;
|
|
var previousCurrent = _simulationStopwatch.ElapsedMilliseconds;
|
|
|
|
_simulationStopwatch.Reset();
|
|
_totalSimulationMilliseconds = 0;
|
|
|
|
if (wasRunning && _mainViewModel.IsSimulationRunning)
|
|
{
|
|
_simulationStopwatch.Start();
|
|
}
|
|
|
|
Debug.WriteLine("[MCP Server] Simulation timing reset");
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = "Simulation timing reset successfully",
|
|
previous_total_ms = previousTotal,
|
|
previous_current_ms = previousCurrent,
|
|
was_running = wasRunning
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
#region Tool Implementations
|
|
|
|
/// <summary>
|
|
/// Lista todos los objetos en la simulación con metadata
|
|
/// </summary>
|
|
private object ListObjects()
|
|
{
|
|
try
|
|
{
|
|
if (!IsDispatcherAvailable())
|
|
{
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
object[] objects;
|
|
bool isRunning;
|
|
|
|
try
|
|
{
|
|
objects = _mainViewModel.ObjetosSimulables?
|
|
.Where(obj => obj.Show_On_This_Page)
|
|
.Select(obj => new
|
|
{
|
|
id = obj.Id,
|
|
name = obj.Nombre,
|
|
type = obj.GetType().Name,
|
|
position = new { x = obj.Left, y = obj.Top },
|
|
dimensions = new { width = obj.Ancho, height = obj.Alto },
|
|
angle = obj.Angulo,
|
|
visible = obj.IsVisFilter,
|
|
locked = obj.Lock_movement,
|
|
tags = obj.ListaEtiquetas?.ToArray() ?? new string[0],
|
|
properties = GetObjectProperties(obj)
|
|
})
|
|
.ToArray() ?? new object[0];
|
|
|
|
isRunning = _mainViewModel.IsSimulationRunning;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error accediendo objetos de simulación: {ex.Message}", "Warning");
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
count = objects.Length,
|
|
simulation_elapsed_ms = GetCurrentSimulationMilliseconds(),
|
|
simulation_running = isRunning,
|
|
objects = objects
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error en ListObjects: {ex.Message}", "Error");
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtiene las propiedades serializables de un objeto
|
|
/// </summary>
|
|
private object GetObjectProperties(osBase obj)
|
|
{
|
|
try
|
|
{
|
|
var settings = new JsonSerializerSettings
|
|
{
|
|
TypeNameHandling = TypeNameHandling.Auto,
|
|
NullValueHandling = NullValueHandling.Ignore,
|
|
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
|
|
};
|
|
|
|
var json = JsonConvert.SerializeObject(obj, settings);
|
|
return JsonConvert.DeserializeObject(json);
|
|
}
|
|
catch
|
|
{
|
|
return new { error = "Could not serialize object properties" };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Crea un nuevo objeto del tipo especificado
|
|
/// </summary>
|
|
private object CreateObject(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var typeName = arguments["type"]?.ToString();
|
|
var x = arguments["x"]?.ToObject<float>() ?? 0f;
|
|
var y = arguments["y"]?.ToObject<float>() ?? 0f;
|
|
var properties = arguments["properties"] as JObject;
|
|
|
|
if (string.IsNullOrEmpty(typeName))
|
|
throw new ArgumentException("Type is required");
|
|
|
|
// Buscar el tipo en la lista de tipos disponibles
|
|
var tipoSimulable = _mainViewModel.ListaOsBase.FirstOrDefault(t =>
|
|
t.Tipo.Name.Equals(typeName, StringComparison.OrdinalIgnoreCase) ||
|
|
t.Nombre.Equals(typeName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (tipoSimulable == null)
|
|
throw new ArgumentException($"Object type '{typeName}' not found");
|
|
|
|
// Crear el objeto
|
|
var newObject = _mainViewModel.CrearObjetoSimulable(tipoSimulable.Tipo, x, y);
|
|
|
|
if (newObject == null)
|
|
throw new Exception("Failed to create object");
|
|
|
|
// Aplicar propiedades adicionales si se proporcionaron
|
|
if (properties != null)
|
|
{
|
|
ApplyPropertiesToObject(newObject, properties);
|
|
}
|
|
|
|
// Crear el UserControl asociado
|
|
_mainViewModel.CrearUserControlDesdeObjetoSimulable(newObject);
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
object_id = newObject.Id,
|
|
message = $"Object of type '{typeName}' created successfully",
|
|
object_data = new
|
|
{
|
|
id = newObject.Id,
|
|
name = newObject.Nombre,
|
|
type = newObject.GetType().Name,
|
|
position = new { x = newObject.Left, y = newObject.Top },
|
|
dimensions = new { width = newObject.Ancho, height = newObject.Alto }
|
|
}
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Actualiza las propiedades de un objeto existente
|
|
/// </summary>
|
|
private object UpdateObject(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var objectId = arguments["id"]?.ToObject<int>();
|
|
var properties = arguments["properties"] as JObject;
|
|
|
|
if (!objectId.HasValue)
|
|
throw new ArgumentException("Object ID is required");
|
|
|
|
if (properties == null)
|
|
throw new ArgumentException("Properties are required");
|
|
|
|
var obj = _mainViewModel.ObjetosSimulables.FirstOrDefault(o => o.Id.Value == objectId.Value);
|
|
if (obj == null)
|
|
throw new ArgumentException($"Object with ID {objectId} not found");
|
|
|
|
ApplyPropertiesToObject(obj, properties);
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
object_id = objectId.Value,
|
|
message = "Object updated successfully"
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aplica propiedades JSON a un objeto
|
|
/// </summary>
|
|
private void ApplyPropertiesToObject(osBase obj, JObject properties)
|
|
{
|
|
var objType = obj.GetType();
|
|
|
|
foreach (var prop in properties)
|
|
{
|
|
try
|
|
{
|
|
var property = objType.GetProperty(prop.Key);
|
|
if (property != null && property.CanWrite)
|
|
{
|
|
var value = prop.Value.ToObject(property.PropertyType);
|
|
property.SetValue(obj, value);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error setting property {prop.Key}: {ex.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina objetos por ID
|
|
/// </summary>
|
|
private object DeleteObjects(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var ids = new List<int>();
|
|
|
|
// Soportar tanto ID único como array de IDs
|
|
if (arguments["id"] != null)
|
|
{
|
|
ids.Add(arguments["id"].ToObject<int>());
|
|
}
|
|
else if (arguments["ids"] != null)
|
|
{
|
|
ids.AddRange(arguments["ids"].ToObject<int[]>());
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentException("Either 'id' or 'ids' is required");
|
|
}
|
|
|
|
var deletedCount = 0;
|
|
var errors = new List<string>();
|
|
|
|
foreach (var id in ids)
|
|
{
|
|
var obj = _mainViewModel.ObjetosSimulables.FirstOrDefault(o => o.Id.Value == id);
|
|
if (obj != null)
|
|
{
|
|
_mainViewModel.RemoverObjetoSimulable(obj);
|
|
deletedCount++;
|
|
}
|
|
else
|
|
{
|
|
errors.Add($"Object with ID {id} not found");
|
|
}
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
deleted_count = deletedCount,
|
|
errors = errors.ToArray(),
|
|
message = $"Deleted {deletedCount} object(s)"
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lista todos los tipos de objetos disponibles para crear
|
|
/// </summary>
|
|
private object ListObjectTypes()
|
|
{
|
|
try
|
|
{
|
|
var types = _mainViewModel.ListaOsBase
|
|
.Select(t => new
|
|
{
|
|
name = t.Nombre,
|
|
type_name = t.Tipo.Name,
|
|
category = t.Categoria,
|
|
full_type_name = t.Tipo.FullName
|
|
})
|
|
.OrderBy(t => t.category)
|
|
.ThenBy(t => t.name)
|
|
.ToArray();
|
|
|
|
var categories = types.GroupBy(t => t.category)
|
|
.Select(g => new
|
|
{
|
|
category = g.Key,
|
|
types = g.ToArray()
|
|
})
|
|
.ToArray();
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
total_types = types.Length,
|
|
categories = categories,
|
|
all_types = types
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inicia la simulación
|
|
/// </summary>
|
|
private object StartSimulation(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
if (!IsDispatcherAvailable())
|
|
{
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
var duration = arguments["duration"]?.ToObject<double?>(); // Duration in seconds
|
|
|
|
bool isRunning;
|
|
try
|
|
{
|
|
isRunning = _mainViewModel.IsSimulationRunning;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error accediendo estado de simulación: {ex.Message}", "Warning");
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
if (isRunning)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = "Simulation is already running"
|
|
};
|
|
}
|
|
|
|
// Use BeginInvoke to start simulation without blocking
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
// Iniciar simulación usando el método privado
|
|
var startMethod = typeof(MainViewModel).GetMethod("StartSimulation", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
startMethod?.Invoke(_mainViewModel, null);
|
|
}), DispatcherPriority.Normal);
|
|
|
|
// Si se especifica duración, programar parada automática
|
|
if (duration.HasValue && duration.Value > 0)
|
|
{
|
|
var timer = new System.Timers.Timer(duration.Value * 1000);
|
|
timer.Elapsed += async (s, e) =>
|
|
{
|
|
timer.Dispose();
|
|
try
|
|
{
|
|
// Use BeginInvoke instead of Invoke to prevent blocking
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_mainViewModel.StopSimulation();
|
|
}), DispatcherPriority.Normal);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error deteniendo simulación automáticamente: {ex.Message}", "Error");
|
|
}
|
|
};
|
|
timer.Start();
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = "Simulation started successfully",
|
|
duration_seconds = duration,
|
|
auto_stop = duration.HasValue,
|
|
simulation_elapsed_ms = GetCurrentSimulationMilliseconds()
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detiene la simulación
|
|
/// </summary>
|
|
private object StopSimulation()
|
|
{
|
|
try
|
|
{
|
|
if (!IsDispatcherAvailable())
|
|
{
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
bool isRunning;
|
|
try
|
|
{
|
|
isRunning = _mainViewModel.IsSimulationRunning;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error accediendo estado de simulación: {ex.Message}", "Warning");
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
if (!isRunning)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = "Simulation is not running"
|
|
};
|
|
}
|
|
|
|
// Use BeginInvoke instead of Invoke to prevent blocking
|
|
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_mainViewModel.StopSimulation();
|
|
}), DispatcherPriority.Normal);
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = "Simulation stopped successfully",
|
|
simulation_elapsed_ms = GetCurrentSimulationMilliseconds(),
|
|
simulation_elapsed_seconds = Math.Round(GetCurrentSimulationMilliseconds() / 1000.0, 3)
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtiene el estado actual de la simulación
|
|
/// </summary>
|
|
private object GetSimulationStatus()
|
|
{
|
|
try
|
|
{
|
|
// Use thread-safe access to properties
|
|
if (!IsDispatcherAvailable())
|
|
{
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
var elapsedMs = GetCurrentSimulationMilliseconds();
|
|
bool isRunning;
|
|
int objectCount;
|
|
int visibleObjects;
|
|
|
|
// Access UI properties safely
|
|
try
|
|
{
|
|
isRunning = _mainViewModel.IsSimulationRunning;
|
|
objectCount = _mainViewModel.ObjetosSimulables?.Count ?? 0;
|
|
visibleObjects = _mainViewModel.ObjetosSimulables?.Count(o => o.Show_On_This_Page) ?? 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error accediendo propiedades de simulación: {ex.Message}", "Warning");
|
|
return new { success = false, error = "CtrEditor not available" };
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
is_running = isRunning,
|
|
simulation_elapsed_ms = elapsedMs,
|
|
simulation_elapsed_seconds = Math.Round(elapsedMs / 1000.0, 3),
|
|
object_count = objectCount,
|
|
visible_objects = visibleObjects
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
AddDebugLogEntry($"[MCP Server] Error en GetSimulationStatus: {ex.Message}", "Error");
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Obtiene el estado de conexión del PLC
|
|
/// </summary>
|
|
private object GetPlcStatus()
|
|
{
|
|
try
|
|
{
|
|
return new
|
|
{
|
|
success = true,
|
|
is_connected = _mainViewModel.IsConnected,
|
|
plc_enabled = _mainViewModel.PLCViewModel != null
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toma una captura de pantalla del canvas usando el nuevo ScreenshotManager
|
|
/// </summary>
|
|
private object TakeScreenshot(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var filename = arguments["filename"]?.ToString();
|
|
var includeBackground = arguments["include_background"]?.ToObject<bool>() ?? false;
|
|
var saveFile = arguments["save_file"]?.ToObject<bool>() ?? true;
|
|
var returnBase64 = arguments["return_base64"]?.ToObject<bool>() ?? true;
|
|
|
|
var x = arguments["x"]?.ToObject<float?>();
|
|
var y = arguments["y"]?.ToObject<float?>();
|
|
var width = arguments["width"]?.ToObject<float?>();
|
|
var height = arguments["height"]?.ToObject<float?>();
|
|
var centerCoordinates = arguments["center_coordinates"]?.ToObject<bool>() ?? false;
|
|
|
|
// Obtener ScreenshotManager de forma lazy
|
|
var screenshotManager = GetScreenshotManager();
|
|
ScreenshotResult result;
|
|
|
|
if (x.HasValue && y.HasValue && width.HasValue && height.HasValue)
|
|
{
|
|
// Captura de área específica
|
|
if (centerCoordinates)
|
|
{
|
|
result = screenshotManager.CaptureCenteredArea(
|
|
x.Value, y.Value, width.Value, height.Value,
|
|
filename, includeBackground, saveFile, returnBase64);
|
|
}
|
|
else
|
|
{
|
|
result = screenshotManager.CaptureArea(
|
|
x.Value, y.Value, width.Value, height.Value,
|
|
filename, includeBackground, saveFile, returnBase64);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Captura de todo el canvas
|
|
result = screenshotManager.CaptureFullCanvas(
|
|
filename, includeBackground, saveFile, returnBase64);
|
|
}
|
|
|
|
if (result.Success)
|
|
{
|
|
return new
|
|
{
|
|
success = true,
|
|
filename = result.FileName,
|
|
full_path = result.FilePath,
|
|
directory = result.Directory,
|
|
file_size_bytes = result.FileSizeBytes,
|
|
timestamp = result.Timestamp.ToString("yyyy-MM-dd HH:mm:ss"),
|
|
message = "Screenshot saved successfully",
|
|
base64_data = returnBase64 ? result.Base64Data : null,
|
|
canvas_info = new
|
|
{
|
|
canvas_width_pixels = _mainViewModel.MainCanvas?.ActualWidth ?? 0,
|
|
canvas_height_pixels = _mainViewModel.MainCanvas?.ActualHeight ?? 0,
|
|
canvas_width_meters = result.CaptureArea?.Width ?? 0,
|
|
canvas_height_meters = result.CaptureArea?.Height ?? 0
|
|
},
|
|
capture_info = new
|
|
{
|
|
include_background = result.IncludeBackground,
|
|
area_specified = x.HasValue && y.HasValue && width.HasValue && height.HasValue,
|
|
area = result.CaptureArea != null ? new
|
|
{
|
|
x = Math.Round(result.CaptureArea.Left, 3),
|
|
y = Math.Round(result.CaptureArea.Top, 3),
|
|
width = Math.Round(result.CaptureArea.Width, 3),
|
|
height = Math.Round(result.CaptureArea.Height, 3),
|
|
center_x = Math.Round(result.CaptureArea.CenterX, 3),
|
|
center_y = Math.Round(result.CaptureArea.CenterY, 3),
|
|
units = "meters"
|
|
} : null,
|
|
capture_type = result.CaptureType.ToString().ToLower(),
|
|
center_coordinates = centerCoordinates
|
|
}
|
|
};
|
|
}
|
|
else
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = result.ErrorMessage,
|
|
error_type = result.ErrorType
|
|
};
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = ex.Message,
|
|
error_type = ex.GetType().Name
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Guarda el proyecto actual
|
|
/// </summary>
|
|
private object SaveProject()
|
|
{
|
|
try
|
|
{
|
|
_mainViewModel.Save();
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = "Project saved successfully"
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new { success = false, error = ex.Message };
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toma una captura de pantalla de objetos específicos por sus IDs usando el nuevo ScreenshotManager
|
|
/// </summary>
|
|
private object TakeObjectScreenshot(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var objectIds = arguments["object_ids"]?.ToObject<string[]>();
|
|
if (objectIds == null || objectIds.Length == 0)
|
|
throw new ArgumentException("object_ids is required and must not be empty");
|
|
|
|
var paddingMeters = arguments["padding_meters"]?.ToObject<float>() ?? 0.5f;
|
|
var filename = arguments["filename"]?.ToString();
|
|
var includeBackground = arguments["include_background"]?.ToObject<bool>() ?? false;
|
|
var saveFile = arguments["save_file"]?.ToObject<bool>() ?? true;
|
|
var returnBase64 = arguments["return_base64"]?.ToObject<bool>() ?? true;
|
|
|
|
// Obtener ScreenshotManager de forma lazy y usar el nuevo método
|
|
var screenshotManager = GetScreenshotManager();
|
|
var result = screenshotManager.CaptureObjects(
|
|
objectIds, paddingMeters, filename, includeBackground, saveFile, returnBase64);
|
|
|
|
if (result.Success)
|
|
{
|
|
return new
|
|
{
|
|
success = true,
|
|
filename = result.FileName,
|
|
full_path = result.FilePath,
|
|
directory = result.Directory,
|
|
file_size_bytes = result.FileSizeBytes,
|
|
timestamp = result.Timestamp.ToString("yyyy-MM-dd HH:mm:ss"),
|
|
message = "Object screenshot saved successfully",
|
|
base64_data = returnBase64 ? result.Base64Data : null,
|
|
captured_objects = result.CapturedObjects.Select(obj => new
|
|
{
|
|
id = obj.Id,
|
|
name = obj.Name,
|
|
type = obj.Type,
|
|
position = new { x = obj.Left, y = obj.Top },
|
|
center = new { x = obj.CenterX, y = obj.CenterY },
|
|
dimensions = new { width = obj.Width, height = obj.Height }
|
|
}).ToArray(),
|
|
bounding_box = new
|
|
{
|
|
left = Math.Round(result.BoundingBox.Left, 3),
|
|
top = Math.Round(result.BoundingBox.Top, 3),
|
|
right = Math.Round(result.BoundingBox.Left + result.BoundingBox.Width, 3),
|
|
bottom = Math.Round(result.BoundingBox.Top + result.BoundingBox.Height, 3),
|
|
center_x = Math.Round(result.BoundingBox.CenterX, 3),
|
|
center_y = Math.Round(result.BoundingBox.CenterY, 3),
|
|
width = Math.Round(result.BoundingBox.Width, 3),
|
|
height = Math.Round(result.BoundingBox.Height, 3)
|
|
},
|
|
capture_area = new
|
|
{
|
|
left = Math.Round(result.CaptureArea.Left, 3),
|
|
top = Math.Round(result.CaptureArea.Top, 3),
|
|
center_x = Math.Round(result.CaptureArea.CenterX, 3),
|
|
center_y = Math.Round(result.CaptureArea.CenterY, 3),
|
|
width = Math.Round(result.CaptureArea.Width, 3),
|
|
height = Math.Round(result.CaptureArea.Height, 3),
|
|
padding_meters = result.PaddingMeters
|
|
},
|
|
capture_info = new
|
|
{
|
|
include_background = result.IncludeBackground,
|
|
capture_type = result.CaptureType.ToString().ToLower(),
|
|
objects_count = result.CapturedObjects.Count
|
|
}
|
|
};
|
|
}
|
|
else
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = result.ErrorMessage,
|
|
error_type = result.ErrorType
|
|
};
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = ex.Message,
|
|
error_type = ex.GetType().Name
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Python Execution Support
|
|
|
|
/// <summary>
|
|
/// Executes Python code using the shared CPython environment from TSNet
|
|
/// </summary>
|
|
private async Task<object> ExecutePythonAsync(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var code = arguments["code"]?.ToString();
|
|
if (string.IsNullOrEmpty(code))
|
|
throw new ArgumentException("Code is required");
|
|
|
|
var returnVariables = arguments["return_variables"]?.ToObject<string[]>() ?? new string[0];
|
|
var timeoutSeconds = arguments["timeout_seconds"]?.ToObject<int>() ?? 30;
|
|
|
|
// Note: Using process-based CPython execution (no DLL initialization needed)
|
|
Debug.WriteLine("[MCP Server] Executing Python script via process-based CPython");
|
|
|
|
// Prepare enhanced script with global variables and helpers
|
|
var enhancedScript = $@"
|
|
# Set up CtrEditor context variables
|
|
import sys
|
|
import json
|
|
import math
|
|
import time
|
|
|
|
# Helper functions
|
|
def get_objects():
|
|
'''Helper function to get all simulable objects as a list'''
|
|
# Note: In CPython mode, direct object access is limited
|
|
print('Note: get_objects() - Direct object access not available in CPython mode')
|
|
return []
|
|
|
|
def safe_print(*args, **kwargs):
|
|
'''Safe print function'''
|
|
try:
|
|
print(*args, **kwargs)
|
|
except:
|
|
pass
|
|
|
|
# Override print with safe version
|
|
print = safe_print
|
|
|
|
# User code starts here
|
|
{code}
|
|
|
|
# Collect return variables if specified
|
|
return_data = {{}}
|
|
{string.Join("\n", returnVariables.Select(var => $"try:\n return_data['{var}'] = {var}\nexcept:\n return_data['{var}'] = None"))}
|
|
|
|
# Output return data as JSON
|
|
if return_data:
|
|
print('RETURN_DATA:' + json.dumps(return_data))
|
|
";
|
|
|
|
// Create temporary script file and execute
|
|
var tempScript = System.IO.Path.Combine(System.IO.Path.GetTempPath(), $"mcp_python_{Guid.NewGuid()}.py");
|
|
try
|
|
{
|
|
await File.WriteAllTextAsync(tempScript, enhancedScript);
|
|
var result = await PythonInterop.ExecuteScriptAsync(tempScript);
|
|
|
|
if (result.Success)
|
|
{
|
|
// Parse return variables from output if available
|
|
var returnValues = new Dictionary<string, object>();
|
|
|
|
// Try to extract return_data from Python output
|
|
if (returnVariables.Length > 0 && result.Output.Contains("RETURN_DATA:"))
|
|
{
|
|
try
|
|
{
|
|
var jsonStart = result.Output.IndexOf("RETURN_DATA:") + "RETURN_DATA:".Length;
|
|
var jsonEnd = result.Output.IndexOf("\n", jsonStart);
|
|
if (jsonEnd == -1) jsonEnd = result.Output.Length;
|
|
|
|
var jsonStr = result.Output.Substring(jsonStart, jsonEnd - jsonStart).Trim();
|
|
var parsedData = JsonConvert.DeserializeObject<Dictionary<string, object>>(jsonStr);
|
|
if (parsedData != null)
|
|
{
|
|
returnValues = parsedData;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error parsing return variables: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// Clean output to remove RETURN_DATA line
|
|
var cleanOutput = result.Output;
|
|
if (cleanOutput.Contains("RETURN_DATA:"))
|
|
{
|
|
var lines = cleanOutput.Split('\n');
|
|
cleanOutput = string.Join("\n", lines.Where(line => !line.StartsWith("RETURN_DATA:")));
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
output = cleanOutput?.Trim() ?? "",
|
|
variables = returnValues,
|
|
exit_code = result.ExitCode,
|
|
python_version = "CPython via PythonInterop"
|
|
};
|
|
}
|
|
else
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = result.Error ?? "Unknown error",
|
|
error_type = "PythonExecutionError",
|
|
output = result.Output,
|
|
exit_code = result.ExitCode
|
|
};
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
// Clean up temporary script file
|
|
try
|
|
{
|
|
if (File.Exists(tempScript))
|
|
File.Delete(tempScript);
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = ex.Message,
|
|
error_type = ex.GetType().Name
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets help information about available Python objects and methods
|
|
/// </summary>
|
|
private object GetPythonHelp(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var objectName = arguments["object_name"]?.ToString();
|
|
|
|
var helpInfo = new Dictionary<string, object>
|
|
{
|
|
["available_objects"] = new
|
|
{
|
|
app = "MainViewModel - Main application view model with all CtrEditor functionality",
|
|
canvas = "Canvas - Main canvas where objects are displayed",
|
|
objects = "Collection of all simulable objects",
|
|
get_objects = "Function() - Helper function that returns objects as a Python list"
|
|
},
|
|
["available_libraries"] = new[]
|
|
{
|
|
"sys - System-specific parameters and functions",
|
|
"math - Mathematical functions",
|
|
"time - Time-related functions",
|
|
"json - JSON encoder and decoder",
|
|
"tsnet - TSNet hydraulic simulation library (if available)"
|
|
},
|
|
["common_usage_patterns"] = new[]
|
|
{
|
|
"len(get_objects()) - Get number of objects",
|
|
"print('Hello') - Print to output",
|
|
"import tsnet - Access TSNet library",
|
|
"# Note: Direct object access limited in CPython mode"
|
|
},
|
|
["python_environment"] = new
|
|
{
|
|
type = "CPython (shared with TSNet)",
|
|
interop = "PythonInterop via process execution",
|
|
note = "Uses same Python environment as TSNet simulations"
|
|
}
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(objectName))
|
|
{
|
|
// For CPython mode, provide general help about the object type
|
|
switch (objectName.ToLower())
|
|
{
|
|
case "app":
|
|
helpInfo["app_help"] = new
|
|
{
|
|
description = "MainViewModel provides access to simulation state and controls",
|
|
common_properties = new[] { "IsSimulationRunning", "ObjetosSimulables" },
|
|
note = "Direct access limited in CPython mode - use specific MCP tools instead"
|
|
};
|
|
break;
|
|
case "canvas":
|
|
helpInfo["canvas_help"] = new
|
|
{
|
|
description = "Main drawing canvas for simulation objects",
|
|
common_properties = new[] { "Width", "Height", "Children" },
|
|
note = "Direct access limited in CPython mode - use screenshot tools instead"
|
|
};
|
|
break;
|
|
case "objects":
|
|
helpInfo["objects_help"] = new
|
|
{
|
|
description = "Collection of simulation objects",
|
|
usage = "Use get_objects() function for safe access",
|
|
note = "Direct object manipulation should use MCP tools"
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
help = helpInfo
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = ex.Message
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Circular Debug Log System
|
|
|
|
/// <summary>
|
|
/// Custom TraceListener for capturing debug output
|
|
/// </summary>
|
|
private class DebugTraceListener : TraceListener
|
|
{
|
|
private readonly MCPServer _server;
|
|
|
|
public DebugTraceListener(MCPServer server)
|
|
{
|
|
_server = server;
|
|
}
|
|
|
|
public override void Write(string message)
|
|
{
|
|
if (!string.IsNullOrEmpty(message))
|
|
{
|
|
_server.AddLogEntry(message, "Debug");
|
|
}
|
|
}
|
|
|
|
public override void WriteLine(string message)
|
|
{
|
|
if (!string.IsNullOrEmpty(message))
|
|
{
|
|
_server.AddLogEntry(message, "Debug");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a log entry to the circular buffer
|
|
/// </summary>
|
|
public void AddLogEntry(string message, string level = "Info")
|
|
{
|
|
if (string.IsNullOrEmpty(message)) return;
|
|
|
|
var entry = new DebugLogEntry(message, level);
|
|
_debugLogBuffer.Enqueue(entry);
|
|
Interlocked.Increment(ref _currentLogCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Timer callback to cleanup old log entries
|
|
/// </summary>
|
|
private void CleanupLogBuffer(object sender, System.Timers.ElapsedEventArgs e)
|
|
{
|
|
lock (_logLock)
|
|
{
|
|
while (_currentLogCount > MAX_LOG_ENTRIES && _debugLogBuffer.TryDequeue(out _))
|
|
{
|
|
Interlocked.Decrement(ref _currentLogCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search debug log with pattern matching
|
|
/// </summary>
|
|
private object SearchDebugLog(JObject arguments)
|
|
{
|
|
try
|
|
{
|
|
var pattern = arguments?["pattern"]?.ToString() ?? "";
|
|
var maxLines = arguments?["max_lines"]?.ToObject<int>() ?? 100;
|
|
var lastNLines = arguments?["last_n_lines"]?.ToObject<int>() ?? 1000;
|
|
var caseSensitive = arguments?["case_sensitive"]?.ToObject<bool>() ?? false;
|
|
|
|
// Get current log entries in chronological order
|
|
var logEntries = _debugLogBuffer.ToArray();
|
|
|
|
// Take only the last N entries if specified
|
|
var entriesToSearch = logEntries.TakeLast(Math.Min(lastNLines, logEntries.Length)).ToArray();
|
|
|
|
var matchingEntries = new List<DebugLogEntry>();
|
|
|
|
if (string.IsNullOrEmpty(pattern))
|
|
{
|
|
// Return all entries if no pattern specified
|
|
matchingEntries.AddRange(entriesToSearch.TakeLast(maxLines));
|
|
}
|
|
else
|
|
{
|
|
// Use regex for pattern matching
|
|
try
|
|
{
|
|
var regexOptions = caseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase;
|
|
var regex = new Regex(pattern, regexOptions);
|
|
|
|
foreach (var entry in entriesToSearch)
|
|
{
|
|
if (regex.IsMatch(entry.Message))
|
|
{
|
|
matchingEntries.Add(entry);
|
|
if (matchingEntries.Count >= maxLines)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
// If regex fails, fall back to simple text search
|
|
var comparison = caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
|
|
|
|
foreach (var entry in entriesToSearch)
|
|
{
|
|
if (entry.Message.IndexOf(pattern, comparison) >= 0)
|
|
{
|
|
matchingEntries.Add(entry);
|
|
if (matchingEntries.Count >= maxLines)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
matches = matchingEntries.Select(entry => new
|
|
{
|
|
timestamp = entry.Timestamp.ToString("yyyy-MM-dd HH:mm:ss.fff"),
|
|
level = entry.Level,
|
|
message = entry.Message
|
|
}).ToArray(),
|
|
total_matches = matchingEntries.Count,
|
|
total_log_entries = _currentLogCount,
|
|
pattern = pattern,
|
|
searched_last_n_lines = entriesToSearch.Length
|
|
};
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new
|
|
{
|
|
success = false,
|
|
error = ex.Message
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get debug log statistics
|
|
/// </summary>
|
|
private object GetDebugStats()
|
|
{
|
|
return new
|
|
{
|
|
success = true,
|
|
current_log_count = _currentLogCount,
|
|
max_log_entries = MAX_LOG_ENTRIES,
|
|
is_buffer_full = _currentLogCount >= MAX_LOG_ENTRIES,
|
|
cleanup_timer_enabled = _logCleanupTimer?.Enabled ?? false
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear the debug log buffer
|
|
/// </summary>
|
|
private object ClearDebugBuffer()
|
|
{
|
|
lock (_logLock)
|
|
{
|
|
while (_debugLogBuffer.TryDequeue(out _))
|
|
{
|
|
Interlocked.Decrement(ref _currentLogCount);
|
|
}
|
|
|
|
return new
|
|
{
|
|
success = true,
|
|
message = "Debug log buffer cleared"
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
|
|
/// <summary>
|
|
/// Crea una respuesta de error JSON-RPC
|
|
/// </summary>
|
|
private string CreateErrorResponse(JToken id, int code, string message, string data = null)
|
|
{
|
|
var error = new
|
|
{
|
|
code = code,
|
|
message = message,
|
|
data = data
|
|
};
|
|
|
|
var response = new
|
|
{
|
|
jsonrpc = "2.0",
|
|
id = id,
|
|
error = error
|
|
};
|
|
|
|
return JsonConvert.SerializeObject(response);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable Implementation
|
|
|
|
public void Dispose()
|
|
{
|
|
Stop();
|
|
_cancellationTokenSource?.Dispose();
|
|
|
|
// Clean up debug log timer
|
|
try
|
|
{
|
|
_logCleanupTimer?.Stop();
|
|
_logCleanupTimer?.Dispose();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error disposing log cleanup timer: {ex.Message}");
|
|
}
|
|
|
|
// Clean up Python resources
|
|
try
|
|
{
|
|
// CPython cleanup is handled by PythonInterop
|
|
// No specific cleanup needed here as we use the shared TSNet environment
|
|
Debug.WriteLine("[MCP Server] Python resources cleaned up (shared CPython environment)");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.WriteLine($"[MCP Server] Error disposing Python resources: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Debug Log Management
|
|
|
|
/// <summary>
|
|
/// Añade una entrada al log de debug circular
|
|
/// </summary>
|
|
private void AddDebugLogEntry(string message, string level = "Info")
|
|
{
|
|
try
|
|
{
|
|
var entry = new DebugLogEntry(message, level);
|
|
_debugLogBuffer.Enqueue(entry);
|
|
|
|
// Incrementar contador thread-safe
|
|
Interlocked.Increment(ref _currentLogCount);
|
|
|
|
// También escribir a Debug.WriteLine para salida inmediata
|
|
Debug.WriteLine(entry.ToString());
|
|
|
|
// Forzar limpieza si el buffer está muy lleno
|
|
if (_currentLogCount > MAX_LOG_ENTRIES * 1.2)
|
|
{
|
|
CleanupLogBuffer(null, null);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Failsafe: no usar AddDebugLogEntry aquí para evitar recursión
|
|
Debug.WriteLine($"[MCP Server] Error adding debug log entry: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|