Add releasePluginIfNotExists task with HTTP 409 handling

- Add new RegistryReleaseIfNotExistsTask that treats HTTP 409 errors as non-failing
- Add releaseIfNotExists method to RegistryClient with duplicate detection
- Register releasePluginIfNotExists and releasePluginToRegistryIfNotExists tasks
- Refactor RegistryClient to eliminate code duplication between release methods
- Extract common HTTP request logic into shared sendReleaseRequest method

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

Co-Authored-By: Claude <[email protected]>

Author: pditommaso

src/main/groovy/io/nextflow/gradle/NextflowPlugin.groovy

@@ -1,5 +1,6 @@
 package io.nextflow.gradle
 
+import io.nextflow.gradle.registry.RegistryReleaseIfNotExistsTask
 import io.nextflow.gradle.registry.RegistryReleaseTask
 import org.gradle.api.Plugin
 import org.gradle.api.Project
@@ -113,6 +114,17 @@ class NextflowPlugin implements Plugin<Project> {
                 description = 'Release plugin to configured destination'
             })
             project.tasks.releasePlugin.dependsOn << project.tasks.releasePluginToRegistry
+
+            // Always create registry release if not exists task - handles duplicates gracefully
+            project.tasks.register('releasePluginToRegistryIfNotExists', RegistryReleaseIfNotExistsTask)
+            project.tasks.releasePluginToRegistryIfNotExists.dependsOn << project.tasks.packagePlugin
+
+            // Always create the main release if not exists task
+            project.tasks.register('releasePluginIfNotExists', {
+                group = 'Nextflow Plugin'
+                description = 'Release plugin to configured destination, skipping if already exists'
+            })
+            project.tasks.releasePluginIfNotExists.dependsOn << project.tasks.releasePluginToRegistryIfNotExists
         }
     }
 

src/main/groovy/io/nextflow/gradle/registry/RegistryClient.groovy

@@ -51,6 +51,53 @@ class RegistryClient {
      * @throws RegistryReleaseException if the upload fails or returns an error
      */
     def release(String id, String version, File file) {
+        def response = sendReleaseRequest(id, version, file)
+        
+        if (response.statusCode() != 200) {
+            throw new RegistryReleaseException(getErrorMessage(response, url.resolve("v1/plugins/release")))
+        }
+    }
+
+    /**
+     * Releases a plugin to the registry with duplicate handling.
+     * 
+     * Uploads the plugin zip file along with metadata to the registry
+     * using a multipart HTTP POST request to the v1/plugins/release endpoint.
+     * Unlike the regular release method, this handles HTTP 409 "DUPLICATE_PLUGIN"
+     * errors as non-failing conditions.
+     * 
+     * @param id The plugin identifier/name
+     * @param version The plugin version (must be valid semver)
+     * @param file The plugin zip file to upload
+     * @return Map with keys: success (boolean), skipped (boolean), message (String)
+     * @throws RegistryReleaseException if the upload fails for reasons other than duplicates
+     */
+    def releaseIfNotExists(String id, String version, File file) {
+        def response = sendReleaseRequest(id, version, file)
+        
+        if (response.statusCode() == 200) {
+            return [success: true, skipped: false, message: null]
+        }
+        
+        if (response.statusCode() == 409) {
+            // HTTP 409 indicates plugin already exists - treat as non-failing
+            return [success: true, skipped: true, message: response.body()]
+        }
+        
+        // For all other errors, throw exception as usual
+        throw new RegistryReleaseException(getErrorMessage(response, url.resolve("v1/plugins/release")))
+    }
+
+    /**
+     * Sends the HTTP release request to the registry.
+     * 
+     * @param id The plugin identifier/name
+     * @param version The plugin version
+     * @param file The plugin zip file to upload
+     * @return HttpResponse from the registry
+     * @throws RegistryReleaseException if the request fails due to network issues
+     */
+    private HttpResponse<String> sendReleaseRequest(String id, String version, File file) {
         def client = HttpClient.newBuilder()
             .connectTimeout(Duration.ofSeconds(30))
             .build()
@@ -68,11 +115,7 @@ class RegistryClient {
             .build()
 
         try {
-            def response = client.send(request, HttpResponse.BodyHandlers.ofString())
-            
-            if (response.statusCode() != 200) {
-                throw new RegistryReleaseException(getErrorMessage(response, requestUri))
-            }
+            return client.send(request, HttpResponse.BodyHandlers.ofString())
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt()
             throw new RegistryReleaseException("Plugin release to ${requestUri} was interrupted: ${e.message}", e)

src/main/groovy/io/nextflow/gradle/registry/RegistryReleaseIfNotExistsTask.groovy

@@ -0,0 +1,74 @@
+package io.nextflow.gradle.registry
+
+import groovy.transform.CompileStatic
+import io.nextflow.gradle.NextflowPluginConfig
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Gradle task for releasing a Nextflow plugin to a registry with duplicate handling.
+ * 
+ * This task uploads the assembled plugin zip file to a configured registry
+ * using the registry's REST API. Unlike the regular release task, this task
+ * treats HTTP 409 "DUPLICATE_PLUGIN" errors as non-failing conditions and
+ * logs an info message instead of failing the build.
+ */
+@CompileStatic
+class RegistryReleaseIfNotExistsTask extends DefaultTask {
+    /**
+     * The plugin zip file to be uploaded to the registry.
+     * By default, this points to the zip file created by the packagePlugin task.
+     */
+    @InputFile
+    final RegularFileProperty zipFile
+
+    RegistryReleaseIfNotExistsTask() {
+        group = 'Nextflow Plugin'
+        description = 'Release the assembled plugin to the registry, skipping if already exists'
+
+        final buildDir = project.layout.buildDirectory.get()
+        zipFile = project.objects.fileProperty()
+        zipFile.convention(project.provider {
+            buildDir.file("distributions/${project.name}-${project.version}.zip")
+        })
+    }
+
+    /**
+     * Executes the registry release task with duplicate handling.
+     * 
+     * This method retrieves the plugin configuration and creates a RegistryClient
+     * to upload the plugin zip file to the configured registry endpoint.
+     * If the plugin already exists (HTTP 409 DUPLICATE_PLUGIN), it logs an info
+     * message and continues without failing.
+     * 
+     * @throws RegistryReleaseException if the upload fails for reasons other than duplicates
+     */
+    @TaskAction
+    def run() {
+        final version = project.version.toString()
+        final plugin = project.extensions.getByType(NextflowPluginConfig)
+        
+        // Get or create registry configuration
+        def registryConfig
+        if (plugin.registry) {
+            registryConfig = plugin.registry
+        } else {
+            // Create default registry config that will use fallback values
+            registryConfig = new RegistryReleaseConfig(project)
+        }
+
+        def registryUri = new URI(registryConfig.resolvedUrl)
+        def client = new RegistryClient(registryUri, registryConfig.resolvedAuthToken)
+        def result = client.releaseIfNotExists(project.name, version, project.file(zipFile)) as Map<String, Object>
+        
+        if (result.skipped as Boolean) {
+            // Plugin already exists - log info message and continue
+            project.logger.lifecycle("ℹ️  Plugin '${project.name}' version ${version} already exists in registry [${registryUri}] - skipping upload")
+        } else {
+            // Celebrate successful plugin upload! 🎉
+            project.logger.lifecycle("🎉 SUCCESS! Plugin '${project.name}' version ${version} has been successfully released to Nextflow Registry [${registryUri}]!")
+        }
+    }
+}