Making JavaFX Applications Scriptable via MCP with jDeploy 6.0

note-manager/
├── .github/
│   └── workflows/
│       └── jdeploy.yml          # GitHub Actions workflow for publishing
├── gradle/
│   └── wrapper/                 # Gradle wrapper files
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/notemanager/
│       │       ├── NoteManager.java   # Entry point with mode detection
│       │       └── GreetingTools.java # Sample MCP tools (we'll replace)
│       └── resources/
│           └── application.properties
├── build.gradle                 # Gradle build configuration
├── gradle.properties            # Quarkus version properties
├── gradlew / gradlew.bat       # Gradle wrapper scripts
├── settings.gradle              # Gradle settings
├── icon.png                     # Application icon
├── package.json                 # jDeploy configuration
└── README.md

// JavaFX
implementation 'org.openjfx:javafx-controls:21'

// jDeploy Desktop Lib - use BOM for version management
implementation platform('ca.weblite:jdeploy-desktop-lib-bom:1.0.0')
implementation 'ca.weblite:jdeploy-desktop-lib-javafx'
implementation 'ca.weblite:jdeploy-desktop-lib-hive-filewatcher'
implementation 'ca.weblite:jdeploy-desktop-lib-bridge'

package com.example.notemanager;

import ca.weblite.jdeploy.app.hive.filewatcher.FileWatcherHiveDriver;
import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.annotations.QuarkusMain;

@QuarkusMain
public class NoteManager {

    public static final String MODE_GUI = "gui";
    public static final String MODE_COMMAND = "command";
    public static final String PROP_MODE = "jdeploy.mode";

    private static final String APP_NAME = "note-manager";

    public static void main(String... args) {
        // Ensure jdeploy.app.name is set (required by the bridge library)
        if (System.getProperty("jdeploy.app.name") == null) {
            System.setProperty("jdeploy.app.name", APP_NAME);
        }

        // Initialize background IPC for the GUI Bridge
        FileWatcherHiveDriver.install();

        String mode = System.getProperty(PROP_MODE, MODE_GUI);

        if (MODE_COMMAND.equalsIgnoreCase(mode)) {
            // MCP server mode: Quarkus handles stdin/stdout MCP protocol
            Quarkus.run(args);
        } else {
            // GUI mode: launch the JavaFX application
            NoteManagerApp.main(args);
        }
    }
}

package com.example.notemanager.model;

import java.time.LocalDateTime;
import java.util.UUID;

public class Note {
    private final String id;
    private String title;
    private String content;
    private final LocalDateTime createdAt;
    private LocalDateTime modifiedAt;

    public Note(String title, String content) {
        this.id = UUID.randomUUID().toString().substring(0, 8);
        this.title = title;
        this.content = content;
        this.createdAt = LocalDateTime.now();
        this.modifiedAt = this.createdAt;
    }

    public String getId() { return id; }
    public String getTitle() { return title; }
    public void setTitle(String title) {
        this.title = title;
        this.modifiedAt = LocalDateTime.now();
    }
    public String getContent() { return content; }
    public void setContent(String content) {
        this.content = content;
        this.modifiedAt = LocalDateTime.now();
    }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public LocalDateTime getModifiedAt() { return modifiedAt; }
}

package com.example.notemanager.model;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class NoteStore {
    private static final NoteStore INSTANCE = new NoteStore();
    private final List<Note> notes = new ArrayList<>();

    public static NoteStore getInstance() { return INSTANCE; }

    private NoteStore() {
        // Start with a sample note
        notes.add(new Note("Welcome", "Welcome to Note Manager! "
            + "This app can be scripted by AI agents via MCP."));
    }

    public synchronized List<Note> getAllNotes() {
        return new ArrayList<>(notes);
    }

    public synchronized Optional<Note> getNote(String id) {
        return notes.stream()
            .filter(n -> n.getId().equals(id))
            .findFirst();
    }

    public synchronized Note createNote(String title, String content) {
        Note note = new Note(title, content);
        notes.add(note);
        return note;
    }

    public synchronized boolean deleteNote(String id) {
        return notes.removeIf(n -> n.getId().equals(id));
    }

    public synchronized List<Note> search(String query) {
        String lower = query.toLowerCase();
        return notes.stream()
            .filter(n -> n.getTitle().toLowerCase().contains(lower)
                || n.getContent().toLowerCase().contains(lower))
            .collect(Collectors.toList());
    }
}

package com.example.notemanager;

import ca.weblite.jdeploy.app.JDeployOpenHandler;
import ca.weblite.jdeploy.app.bridge.GuiBridgeHandler;
import ca.weblite.jdeploy.app.bridge.GuiBridgeReceiver;
import ca.weblite.jdeploy.app.javafx.JDeployFXApp;
import com.example.notemanager.model.Note;
import com.example.notemanager.model.NoteStore;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.geometry.Insets;
import javafx.geometry.Orientation;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;

import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class NoteManagerApp extends Application {
    private Stage primaryStage;
    private ListView<Note> noteListView;
    private ObservableList<Note> noteItems;
    private TextArea contentArea;
    private TextField titleField;
    private TextField searchField;
    private final NoteStore store = NoteStore.getInstance();

    private GuiBridgeReceiver bridgeReceiver;

    public static void main(String[] args) {
        // IMPORTANT: Initialize JDeployFXApp before launching JavaFX.
        // On macOS, this registers AWT Desktop handlers while AWT is still
        // the primary toolkit. Without this, deep links won't be received.
        JDeployFXApp.initialize();
        launch(args);
    }

    @Override
    public void start(Stage stage) {
        this.primaryStage = stage;

        // --- Sidebar: note list + search + new button ---
        searchField = new TextField();
        searchField.setPromptText("Search notes...");
        searchField.textProperty().addListener((obs, oldVal, newVal) -> refreshList());

        noteItems = FXCollections.observableArrayList(store.getAllNotes());
        noteListView = new ListView<>(noteItems);
        noteListView.setCellFactory(lv -> new ListCell<>() {
            @Override
            protected void updateItem(Note note, boolean empty) {
                super.updateItem(note, empty);
                setText(empty || note == null ? null : note.getTitle());
            }
        });
        noteListView.getSelectionModel().selectedItemProperty()
            .addListener((obs, oldNote, newNote) -> showNote(newNote));

        Button newButton = new Button("New Note");
        newButton.setMaxWidth(Double.MAX_VALUE);
        newButton.setOnAction(e -> createNewNote());

        VBox sidebar = new VBox(8, searchField, noteListView, newButton);
        sidebar.setPadding(new Insets(10));
        sidebar.setPrefWidth(250);
        VBox.setVgrow(noteListView, Priority.ALWAYS);

        // --- Editor: title + content ---
        titleField = new TextField();
        titleField.setPromptText("Note title");
        titleField.setStyle("-fx-font-size: 16px; -fx-font-weight: bold;");
        titleField.textProperty().addListener((obs, oldVal, newVal) -> {
            Note selected = noteListView.getSelectionModel().getSelectedItem();
            if (selected != null) {
                selected.setTitle(newVal);
                noteListView.refresh();
            }
        });

        contentArea = new TextArea();
        contentArea.setPromptText("Start writing...");
        contentArea.setWrapText(true);
        contentArea.textProperty().addListener((obs, oldVal, newVal) -> {
            Note selected = noteListView.getSelectionModel().getSelectedItem();
            if (selected != null) {
                selected.setContent(newVal);
            }
        });

        VBox editor = new VBox(8, titleField, contentArea);
        editor.setPadding(new Insets(10));
        VBox.setVgrow(contentArea, Priority.ALWAYS);

        // --- Layout ---
        SplitPane root = new SplitPane(sidebar, editor);
        root.setOrientation(Orientation.HORIZONTAL);
        root.setDividerPositions(0.3);

        Scene scene = new Scene(root, 900, 600);
        stage.setTitle("Note Manager");
        stage.setScene(scene);

        // Set up MCP command handling via GuiBridge
        setupBridgeReceiver();

        // Register deep link handler (for "show_note" and fallback)
        registerDeepLinkHandler();

        stage.show();

        // Select first note
        if (!noteItems.isEmpty()) {
            noteListView.getSelectionModel().select(0);
        }
    }

    // =========================================================================
    // GUI BRIDGE SETUP
    // =========================================================================

    private void setupBridgeReceiver() {
        // Create handler that processes MCP commands
        GuiBridgeHandler handler = this::handleCommand;

        // Create receiver and register for background commands
        bridgeReceiver = new GuiBridgeReceiver(handler);
        bridgeReceiver.registerHiveListener(requestPath ->
                Platform.runLater(() -> bridgeReceiver.processRequest(requestPath)));
    }

    private Map<String, String> handleCommand(String command, Map<String, String> params) {
        return switch (command) {
            case "list_notes" -> {
                Map<String, String> result = new HashMap<>();
                List<Note> notes = store.getAllNotes();
                result.put("count", String.valueOf(notes.size()));
                int i = 0;
                for (Note n : notes) {
                    result.put("note." + i + ".id", n.getId());
                    result.put("note." + i + ".title", n.getTitle());
                    result.put("note." + i + ".createdAt", n.getCreatedAt().toString());
                    result.put("note." + i + ".modifiedAt", n.getModifiedAt().toString());
                    i++;
                }
                yield result;
            }

            case "get_note" -> {
                String noteId = params.get("id");
                Note note = store.getNote(noteId)
                        .orElseThrow(() -> new RuntimeException("Note not found: " + noteId));
                yield Map.of(
                        "id", note.getId(),
                        "title", note.getTitle(),
                        "content", note.getContent(),
                        "createdAt", note.getCreatedAt().toString(),
                        "modifiedAt", note.getModifiedAt().toString()
                );
            }

            case "create_note" -> {
                String title = params.get("title");
                String content = params.getOrDefault("content", "");
                Note note = store.createNote(title, content);
                refreshList();
                yield Map.of(
                        "id", note.getId(),
                        "title", note.getTitle(),
                        "createdAt", note.getCreatedAt().toString(),
                        "modifiedAt", note.getModifiedAt().toString()
                );
            }

            case "search_notes" -> {
                String query = params.get("query");
                Map<String, String> result = new HashMap<>();
                List<Note> notes = store.search(query);
                result.put("count", String.valueOf(notes.size()));
                int i = 0;
                for (Note n : notes) {
                    result.put("note." + i + ".id", n.getId());
                    result.put("note." + i + ".title", n.getTitle());
                    i++;
                }
                yield result;
            }

            case "show_note" -> {
                String noteId = params.get("id");
                navigateToNote(noteId);
                yield Map.of("shown", "true");
            }

            case "export_note" -> {
                String noteId = params.get("id");
                String outputPath = params.get("path");
                Note note = store.getNote(noteId)
                        .orElseThrow(() -> new RuntimeException("Note not found: " + noteId));
                try {
                    Files.writeString(Path.of(outputPath),
                            "# " + note.getTitle() + "\n\n" + note.getContent());
                } catch (IOException e) {
                    throw new RuntimeException("Failed to export: " + e.getMessage());
                }
                yield Map.of("exported", "true", "path", outputPath);
            }

            default -> throw new IllegalArgumentException("Unknown command: " + command);
        };
    }

    // =========================================================================
    // DEEP LINK HANDLER
    // =========================================================================

    private void registerDeepLinkHandler() {
        JDeployFXApp.setOpenHandler(new JDeployOpenHandler() {
            @Override
            public void openFiles(List<File> files) {
                // Not used in this tutorial
            }

            @Override
            public void openURIs(List<URI> uris) {
                for (URI uri : uris) {
                    if ("notemanager".equals(uri.getScheme()) && "bridge".equals(uri.getHost())) {
                        // Process via bridge receiver
                        bridgeReceiver.processDeepLink(uri);
                    }
                }
            }

            @Override
            public void appActivated() {
                primaryStage.setIconified(false);
                primaryStage.toFront();
                primaryStage.requestFocus();
            }
        });
    }

    // =========================================================================
    // NOTE DISPLAY
    // =========================================================================

    private void showNote(Note note) {
        if (note == null) {
            titleField.clear();
            contentArea.clear();
            return;
        }
        titleField.setText(note.getTitle());
        contentArea.setText(note.getContent());
    }

    private void createNewNote() {
        Note note = store.createNote("Untitled", "");
        refreshList();
        noteListView.getSelectionModel().select(note);
        titleField.requestFocus();
        titleField.selectAll();
    }

    public void refreshList() {
        String query = searchField.getText();
        List<Note> filtered = (query == null || query.isBlank())
            ? store.getAllNotes()
            : store.search(query);
        noteItems.setAll(filtered);
    }

    public void navigateToNote(String noteId) {
        store.getNote(noteId).ifPresent(note -> {
            searchField.clear();
            refreshList();
            noteListView.getSelectionModel().select(note);
            noteListView.scrollTo(note);
            primaryStage.setIconified(false);
            primaryStage.toFront();
            primaryStage.requestFocus();
        });
    }
}

// Create handler that processes MCP commands
GuiBridgeHandler handler = this::handleCommand;

// Create receiver and register for background commands
GuiBridgeReceiver bridgeReceiver = new GuiBridgeReceiver(handler);
bridgeReceiver.registerHiveListener(requestPath ->
        Platform.runLater(() -> bridgeReceiver.processRequest(requestPath)));

private Map<String, String> handleCommand(String command, Map<String, String> params) {
    return switch (command) {
        case "list_notes" -> {
            Map<String, String> result = new HashMap<>();
            List<Note> notes = store.getAllNotes();
            result.put("count", String.valueOf(notes.size()));
            int i = 0;
            for (Note n : notes) {
                result.put("note." + i + ".id", n.getId());
                result.put("note." + i + ".title", n.getTitle());
                i++;
            }
            yield result;
        }
        case "create_note" -> {
            Note note = store.createNote(params.get("title"), params.getOrDefault("content", ""));
            refreshList();
            yield Map.of("id", note.getId(), "title", note.getTitle());
        }
        // ... other commands
        default -> throw new IllegalArgumentException("Unknown command: " + command);
    };
}

package com.example.notemanager.mcp;

import ca.weblite.jdeploy.app.bridge.GuiBridge;
import io.quarkiverse.mcp.server.Tool;
import io.quarkiverse.mcp.server.ToolArg;

import java.util.Map;

public class NoteManagerTools {

    // GuiBridge handles all IPC with the GUI
    private static final GuiBridge bridge = new GuiBridge("notemanager");

    @Tool(description = "List all notes in the Note Manager. "
            + "Returns note IDs, titles, and timestamps.")
    public String listNotes() throws Exception {
        Map<String, String> result = bridge.sendCommand("list_notes", Map.of());
        return formatResult(result);
    }

    @Tool(description = "Get the full content of a note by its ID.")
    public String getNote(
            @ToolArg(description = "The note ID") String id) throws Exception {
        Map<String, String> result = bridge.sendCommand("get_note", Map.of("id", id));
        return formatResult(result);
    }

    @Tool(description = "Create a new note with the given title and content.")
    public String createNote(
            @ToolArg(description = "The note title") String title,
            @ToolArg(description = "The note content") String content) throws Exception {
        Map<String, String> result = bridge.sendCommand("create_note",
                Map.of("title", title, "content", content));
        return formatResult(result);
    }

    @Tool(description = "Search notes by keyword. Searches both titles and content.")
    public String searchNotes(
            @ToolArg(description = "The search query") String query) throws Exception {
        Map<String, String> result = bridge.sendCommand("search_notes", Map.of("query", query));
        return formatResult(result);
    }

    @Tool(description = "Navigate the Note Manager GUI to display a specific note. "
            + "Brings the window to the front.")
    public String showNote(
            @ToolArg(description = "The note ID to display") String id) throws Exception {
        // Use deep link because this command should bring the app to the foreground
        Map<String, String> result = bridge.sendCommandViaDeepLink("show_note", Map.of("id", id));
        return formatResult(result);
    }

    @Tool(description = "Export a note to a file. The note is written as Markdown.")
    public String exportNote(
            @ToolArg(description = "The note ID to export") String id,
            @ToolArg(description = "The file path to write to") String path) throws Exception {
        Map<String, String> result = bridge.sendCommand("export_note",
                Map.of("id", id, "path", path));
        return formatResult(result);
    }

    private static String formatResult(Map<String, String> result) {
        StringBuilder sb = new StringBuilder("{");
        boolean first = true;
        for (Map.Entry<String, String> entry : result.entrySet()) {
            if (!first) sb.append(", ");
            first = false;
            sb.append("\"").append(entry.getKey()).append("\": ");
            sb.append("\"").append(escapeJson(entry.getValue())).append("\"");
        }
        sb.append("}");
        return sb.toString();
    }

    private static String escapeJson(String s) {
        if (s == null) return "";
        return s.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\n", "\\n")
                .replace("\r", "\\r")
                .replace("\t", "\\t");
    }
}

note-manager/
├── .github/
│   └── workflows/
│       └── jdeploy.yml
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/notemanager/
│       │       ├── NoteManager.java       # Entry point
│       │       ├── NoteManagerApp.java    # JavaFX GUI
│       │       ├── model/
│       │       │   ├── Note.java          # Note data model
│       │       │   └── NoteStore.java     # In-memory store
│       │       └── mcp/
│       │           └── NoteManagerTools.java  # MCP tool definitions
│       └── resources/
│           └── application.properties
├── build.gradle
├── package.json
└── ...

./gradlew buildUberJar
jdeploy install

Create a note called "Meeting Notes" with the content
"Discuss Q4 budget, review hiring pipeline, plan offsite."

Search my notes for "budget"

Show me the Meeting Notes note in the app.

Export all notes about "project" to ~/Desktop/notes/

cd note-manager
git init
git add .
git commit -m "Initial commit: Note Manager with MCP support"
git remote add origin https://github.com/yourusername/note-manager.git
git push -u origin master

./gradlew buildUberJar

git tag v1.0.0
git push origin v1.0.0