MineMCP : Interfaçage Asynchrone et Capture de Flux sur Bukkit

// Dans MineServer.java
public void start(int port) {
    // Isolation du ClassLoader pour protéger l'exécution de Javalin
    ClassLoader originalLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(MineServer.class.getClassLoader());
 
    try {
        app = Javalin.create(config -> {
            config.bundledPlugins.enableCors(cors -> cors.addRule(CorsPluginConfig.CorsRule::anyHost));
            config.showJavalinBanner = false;
        });
 
        // Définition des endpoints MCP
        app.before(this::handleAuth);
        app.sse("/sse", this::handleSseConnection); // Canal unidirectionnel Serveur -> Client
        app.post("/messages", this::handleMessage); // Canal unidirectionnel Client -> Serveur
 
        app.start(port);
    } finally {
        // Restauration du ClassLoader de Bukkit
        Thread.currentThread().setContextClassLoader(originalLoader);
    }
}

// Dans McpTool.java
public abstract class McpTool {
    protected static final ObjectMapper mapper = new ObjectMapper();
    protected final String name;
    protected final String description;
 
    // L'outil doit exposer un JSON Schema compréhensible par le LLM client
    public abstract ObjectNode getSchema();
 
    // L'exécution prend des arguments JSON parsés et retourne une réponse JSON
    public abstract ObjectNode execute(JsonNode args) throws Exception;
 
    // Utilitaire interne pour générer une réponse texte standard MCP
    protected ObjectNode createTextResult(String text) {
        ObjectNode result = mapper.createObjectNode();
        result.putArray("content").addObject().put("type", "text").put("text", text);
        return result;
    }
}

// Dans ExecuteCommandTool.java
public ObjectNode execute(JsonNode args) throws Exception {
    String command = args.get("command").asText();
    CompletableFuture<String> future = new CompletableFuture<>();
 
    // Exécution forcée sur le Thread principal du jeu
    Bukkit.getScheduler().runTask(MineMCP.getInstance(), () -> {
        try {
            // [...] Logique d'exécution (détaillée ci-dessous)
            future.complete(capturedOutput);
        } catch (Throwable t) {
            future.completeExceptionally(t);
        }
    });
 
    try {
        // Le thread MCP attend la réponse avec un Timeout de sécurité de 10s
        String result = future.get(10, TimeUnit.SECONDS);
        return createTextResult(result);
    } catch (TimeoutException e) {
        return createTextResult("Command sent but response timed out.");
    }
}

// Dans McpCommandSender.java
public class McpCommandSender implements CommandSender {
    private final StringBuilder output = new StringBuilder();
    private final CommandSender wrappedSender; // Le sender natif enveloppé
 
    public McpCommandSender(CommandSender wrappedSender) {
        this.wrappedSender = wrappedSender;
    }
 
    // Interception de l'API Spigot (BaseComponent)
    private final CommandSender.Spigot spigotProxy = new CommandSender.Spigot() {
        @Override
        public void sendMessage(BaseComponent... components) {
            try {
                // Conversion des composants formatés en texte lisible par l'IA
                String text = TextComponent.toLegacyText(components);
                if (!text.isEmpty()) {
                    output.append(text).append('\n');
                }
            } catch (Throwable ignored) {}
            // On fait suivre au sender original pour maintenir le fonctionnement habituel
            wrappedSender.spigot().sendMessage(components);
        }
    };
    
    // ... Autres méthodes d'interface qui alimentent le StringBuilder
}

// Fallback critique dans ExecuteCommandTool.java
if (captured == null || captured.isEmpty()) {
    StringBuilder logCapture = new StringBuilder();
    Logger bukkitLogger = Bukkit.getLogger();
    
    // Handler fantôme pour intercepter les stdout
    Handler handler = new Handler() {
        @Override
        public void publish(LogRecord record) {
            if (record == null) return;
            String msg = record.getMessage();
            if (msg != null && !msg.isEmpty()) {
                logCapture.append(msg).append('\n');
            }
        }
        @Override public void flush() {}
        @Override public void close() throws SecurityException {}
    };
 
    try {
        bukkitLogger.addHandler(handler);
        // On exécute avec la vraie Console pour garantir que le log s'affiche
        Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
    } finally {
        // Désamorçage obligatoire : Empêche une fuite de mémoire sévère
        bukkitLogger.removeHandler(handler);
    }
    
    captured = "(captured from server logs)\n" + logCapture.toString();
}