Add Windows URI scheme registration

Implements automatic registration of URI schemes with the Windows
Registry, enabling users to click custom links (e.g., fiji://open)
in browsers or other applications to launch the Java application.

Key components:
- SchemeInstaller interface for platform-independent scheme registration
- WindowsSchemeInstaller using Windows reg commands (no JNA dependency)
- LinkHandler.getSchemes() for handlers to declare supported schemes
- DefaultLinkService auto-registers schemes on context initialization

The launcher sets the scijava.app.executable system property to
specify the executable path for registration.

Registration uses HKEY_CURRENT_USER and requires no admin privileges.
Includes comprehensive tests and documentation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ctrueden

README.md

@@ -8,3 +8,59 @@ to manage their integration with the system native desktop:
 
 The scijava-desktop component requires Java 11 as a minimum, due
 to its use of java.awt.Desktop features not present in Java 8.
+
+## Features
+
+- **Link handling**: Register custom handlers for URI schemes through the `LinkHandler` plugin interface
+- **CLI integration**: Automatic handling of URI arguments passed on the command line via `ConsoleArgument`
+- **OS integration**: Automatic registration of URI schemes with the operating system (Windows supported, macOS/Linux planned)
+
+## Usage
+
+### Creating a Link Handler
+
+Implement the `LinkHandler` interface to handle custom URI schemes:
+
+```java
+@Plugin(type = LinkHandler.class)
+public class MyLinkHandler extends AbstractLinkHandler {
+
+    @Override
+    public boolean supports(URI uri) {
+        return "myapp".equals(uri.getScheme());
+    }
+
+    @Override
+    public void handle(URI uri) {
+        // Handle the URI
+        System.out.println("Handling: " + uri);
+    }
+
+    @Override
+    public List<String> getSchemes() {
+        // Return schemes to register with the OS
+        return Arrays.asList("myapp");
+    }
+}
+```
+
+### OS Registration
+
+On Windows, URI schemes returned by `LinkHandler.getSchemes()` are automatically registered
+in the Windows Registry when the `LinkService` initializes. This allows users to click
+links like `myapp://action` in web browsers or other applications, which will launch your
+Java application with the URI as a command-line argument.
+
+The registration uses `HKEY_CURRENT_USER` and requires no administrator privileges.
+
+See [doc/WINDOWS.md](doc/WINDOWS.md) for details.
+
+## Architecture
+
+- `LinkService` - Service for routing URIs to appropriate handlers
+- `LinkHandler` - Plugin interface for implementing custom URI handlers
+- `LinkArgument` - Console argument plugin that recognizes URIs on the command line
+- `SchemeInstaller` - Interface for OS-specific URI scheme registration
+- `WindowsSchemeInstaller` - Windows implementation using registry commands
+
+The launcher should set the `scijava.app.executable` system property to enable URI scheme registration.

doc/WINDOWS.md

@@ -0,0 +1,136 @@
+# Windows URI Scheme Registration
+
+This document describes how URI scheme registration works on Windows in scijava-links.
+
+## Overview
+
+When a SciJava application starts on Windows, the `DefaultLinkService` automatically:
+
+1. Collects all URI schemes from registered `LinkHandler` plugins via `getSchemes()`
+2. Reads the executable path from the `scijava.app.executable` system property
+3. Registers each scheme in the Windows Registry under `HKEY_CURRENT_USER\Software\Classes`
+
+## Registry Structure
+
+For a scheme named `myapp`, the following registry structure is created:
+
+```
+HKEY_CURRENT_USER\Software\Classes\myapp
+    (Default) = "URL:myapp"
+    URL Protocol = ""
+    shell\
+        open\
+            command\
+                (Default) = "C:\Path\To\App.exe" "%1"
+```
+
+## Implementation Details
+
+### SchemeInstaller Interface
+
+The `SchemeInstaller` interface provides a platform-independent API for URI scheme registration:
+
+- `isSupported()` - Checks if the installer works on the current platform
+- `install(scheme, executablePath)` - Registers a URI scheme
+- `isInstalled(scheme)` - Checks if a scheme is already registered
+- `getInstalledPath(scheme)` - Gets the executable path for a registered scheme
+- `uninstall(scheme)` - Removes a URI scheme registration
+
+### WindowsSchemeInstaller
+
+The Windows implementation uses the `reg` command-line tool to manipulate the registry:
+
+- **No JNA dependency**: Uses native Windows `reg` commands via `ProcessBuilder`
+- **No admin rights**: Registers under `HKEY_CURRENT_USER` (not `HKEY_LOCAL_MACHINE`)
+- **Idempotent**: Safely handles re-registration with the same or different paths
+- **Robust error handling**: Proper timeouts, error logging, and validation
+
+### Executable Path Configuration
+
+The launcher must set the `scijava.app.executable` system property to the absolute path of the application's executable. This property is used by `DefaultLinkService` during URI scheme registration.
+
+Example launcher configuration:
+```bash
+java -Dscijava.app.executable="C:\Program Files\MyApp\MyApp.exe" -jar myapp.jar
+```
+
+On Windows, the launcher typically sets this to the `.exe` file path. On macOS, it would be the path inside the `.app` bundle. On Linux, it would be the shell script or executable.
+
+## Example Handler
+
+Here's a complete example of a `LinkHandler` that registers a custom scheme:
+
+```java
+package com.example;
+
+import org.scijava.links.AbstractLinkHandler;
+import org.scijava.links.LinkHandler;
+import org.scijava.log.LogService;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+
+@Plugin(type = LinkHandler.class)
+public class ExampleLinkHandler extends AbstractLinkHandler {
+
+    @Parameter(required = false)
+    private LogService log;
+
+    @Override
+    public boolean supports(final URI uri) {
+        return "example".equals(uri.getScheme());
+    }
+
+    @Override
+    public void handle(final URI uri) {
+        if (log != null) {
+            log.info("Handling example URI: " + uri);
+        }
+
+        // Parse the URI and perform actions
+        String operation = Links.operation(uri);
+        Map<String, String> params = Links.query(uri);
+
+        // Your business logic here
+        // ...
+    }
+
+    @Override
+    public List<String> getSchemes() {
+        // This tells the system to register "example://" links on Windows
+        return Arrays.asList("example");
+    }
+}
+```
+
+## Testing
+
+The Windows scheme installation can be tested on Windows systems:
+
+```bash
+mvn test -Dtest=WindowsSchemeInstallerTest
+```
+
+Tests are automatically skipped on non-Windows platforms using JUnit's `Assume.assumeTrue()`.
+
+To test with a specific executable path, set the system property:
+```bash
+mvn test -Dscijava.app.executable="C:\Path\To\App.exe"
+```
+
+## Platform Notes
+
+**macOS**: URI schemes are declared in the application's `Info.plist` within the `.app` bundle. This is configured at build/packaging time, not at runtime, since the bundle is typically code-signed and immutable.
+
+**Linux**: URI schemes are declared in `.desktop` files, which is part of broader desktop integration (icons, MIME types, etc.). This functionality belongs in `scijava-plugins-platforms` rather than this component.
+
+**Windows**: Runtime registration is appropriate because the Windows Registry is designed for runtime modifications, and registration under `HKEY_CURRENT_USER` requires no elevated privileges.
+
+## Future Enhancements
+
+- **Scheme validation**: Validate scheme names against RFC 3986
+- **User prompts**: Optional confirmation before registering schemes
+- **Uninstallation**: Automatic cleanup on application uninstall

src/main/java/org/scijava/desktop/links/DefaultLinkService.java

@@ -30,12 +30,18 @@
 
 import org.scijava.event.ContextCreatedEvent;
 import org.scijava.event.EventHandler;
+import org.scijava.desktop.links.SchemeInstaller;
+import org.scijava.desktop.platform.windows.WindowsSchemeInstaller;
+import org.scijava.log.LogService;
 import org.scijava.plugin.AbstractHandlerService;
+import org.scijava.plugin.Parameter;
 import org.scijava.plugin.Plugin;
 import org.scijava.service.Service;
 
 import java.awt.Desktop;
 import java.net.URI;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Default implementation of {@link LinkService}.
@@ -45,13 +51,84 @@
 @Plugin(type = Service.class)
 public class DefaultLinkService extends AbstractHandlerService<URI, LinkHandler> implements LinkService {
 
+	@Parameter(required = false)
+	private LogService log;
+
 	@EventHandler
 	private void onEvent(final ContextCreatedEvent evt) {
 		// Register URI handler with the desktop system, if possible.
-		if (!Desktop.isDesktopSupported()) return;
-		final Desktop desktop = Desktop.getDesktop();
-		if (!desktop.isSupported(Desktop.Action.APP_OPEN_URI)) return;
-		desktop.setOpenURIHandler(event -> handle(event.getURI()));
+		if (Desktop.isDesktopSupported()) {
+			final Desktop desktop = Desktop.getDesktop();
+			if (desktop.isSupported(Desktop.Action.APP_OPEN_URI)) {
+				desktop.setOpenURIHandler(event -> handle(event.getURI()));
+			}
+		}
+
+		// Register URI schemes with the operating system (Windows only).
+		installSchemes();
+	}
+
+	/**
+	 * Installs URI schemes with the operating system.
+	 * <p>
+	 * This method collects all schemes supported by registered {@link LinkHandler}
+	 * plugins and registers them with the OS (currently Windows only).
+	 * </p>
+	 */
+	private void installSchemes() {
+		// Create the appropriate installer for this platform
+		final SchemeInstaller installer = createInstaller();
+		if (installer == null || !installer.isSupported()) {
+			if (log != null) log.debug("Scheme installation not supported on this platform");
+			return;
+		}
+
+		// Get executable path from system property
+		final String executablePath = System.getProperty("scijava.app.executable");
+		if (executablePath == null) {
+			if (log != null) log.debug("No executable path set (scijava.app.executable property)");
+			return;
+		}
+
+		// Collect all schemes from registered handlers
+		final Set<String> schemes = collectSchemes();
+		if (schemes.isEmpty()) {
+			if (log != null) log.debug("No URI schemes to register");
+			return;
+		}
+
+		// Install each scheme
+		for (final String scheme : schemes) {
+			try {
+				installer.install(scheme, executablePath);
+			}
+			catch (final Exception e) {
+				if (log != null) log.error("Failed to install URI scheme: " + scheme, e);
+			}
+		}
+	}
+
+	/**
+	 * Creates the appropriate {@link SchemeInstaller} for the current platform.
+	 * <p>
+	 * Currently only Windows is supported. macOS uses Info.plist in the .app bundle
+	 * (configured at build time), and Linux .desktop file management belongs in
+	 * scijava-plugins-platforms.
+	 * </p>
+	 */
+	private SchemeInstaller createInstaller() {
+		return new WindowsSchemeInstaller(log);
+	}
+
+	/**
+	 * Collects all URI schemes from registered {@link LinkHandler} plugins.
+	 */
+	private Set<String> collectSchemes() {
+		final Set<String> schemes = new HashSet<>();
+		for (final LinkHandler handler : getInstances()) {
+			schemes.addAll(handler.getSchemes());
+		}
+		return schemes;
 	}
 
 }

src/main/java/org/scijava/desktop/links/LinkHandler.java

@@ -31,6 +31,8 @@
 import org.scijava.plugin.HandlerPlugin;
 
 import java.net.URI;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * A plugin for handling URI links.
@@ -46,6 +48,21 @@ public interface LinkHandler extends HandlerPlugin<URI> {
      */
     void handle(URI uri);
 
+    /**
+     * Gets the URI schemes that this handler supports.
+     * <p>
+     * This method is used for registering URI schemes with the operating system.
+     * Handlers should return a list of scheme names (e.g., "fiji", "imagej")
+     * that they can handle. Return an empty list if the handler does not
+     * require OS-level scheme registration.
+     * </p>
+     *
+     * @return List of URI schemes supported by this handler
+     */
+    default List<String> getSchemes() {
+        return Collections.emptyList();
+    }
+
     @Override
     default Class<URI> getType() {
         return URI.class;