revert(nf-tower): Revert tower-java-sdk to manual HTTP implementation

The tower-java-sdk dependency from GitHub Packages requires authentication
even for public packages, causing CI build failures. This reverts the SDK
refactoring and restores the manual HTTP implementation.

Changes:
- Removed tower-java-sdk dependency from build.gradle
- Restored manual HTTP methods in TowerClient.groovy:
  - getUrlDatasets() and getUrlDatasetUpload() URL helpers
  - createDataset() with JSON payload and sendHttpMessage()
  - uploadFile() multipart HTTP implementation
  - createMultipartBody() RFC 2388 implementation (~120 lines total)
- Simplified TowerClientTest.groovy to remove SDK-specific tests
- Kept core functionality tests and integration test

Functionality remains identical - only the implementation approach changed
from SDK calls to direct HTTP requests. This allows the plugin to build
successfully in CI without requiring GitHub Package authentication.

Signed-off-by: Edmund Miller <edmund.miller@seqera.io>

Author: edmundmiller

plugins/nf-tower/build.gradle

@@ -30,16 +30,6 @@ nextflowPlugin {
     ]
 }
 
-repositories {
-    maven {
-        url = uri("https://maven.pkg.github.com/seqeralabs/tower-java-sdk")
-        credentials {
-            username = project.findProperty('github_username') ?: System.getenv("GITHUB_USERNAME")
-            password = project.findProperty('github_access_token') ?: System.getenv("GITHUB_TOKEN")
-        }
-    }
-}
-
 sourceSets {
     main.java.srcDirs = []
     main.groovy.srcDirs = ['src/main']
@@ -60,7 +50,6 @@ dependencies {
     compileOnly 'org.pf4j:pf4j:3.12.0'
     compileOnly 'io.seqera:lib-httpx:2.1.0'
 
-    api 'io.seqera.tower:tower-java-sdk:1.43.1'
     api "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.15.0"
     api "com.fasterxml.jackson.core:jackson-databind:2.12.7.1"
 

plugins/nf-tower/src/main/io/seqera/tower/plugin/DatasetConfig.groovy

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2013-2024, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package io.seqera.tower.plugin
+
+import groovy.transform.CompileStatic
+import nextflow.config.spec.ConfigOption
+import nextflow.script.dsl.Description
+
+/**
+ * Model Seqera Platform dataset upload configuration
+ *
+ * @author Edmund Miller <edmund.a.miller@gmail.com>
+ */
+@CompileStatic
+class DatasetConfig {
+
+    @ConfigOption
+    @Description("""
+        Enable automatic upload of workflow outputs to Seqera Platform datasets (default: `false`).
+    """)
+    final boolean enabled
+
+    @ConfigOption
+    @Description("""
+        Dataset creation mode: `auto` to automatically create datasets, `existing` to only use existing datasets (default: `auto`).
+    """)
+    final String createMode
+
+    @ConfigOption
+    @Description("""
+        Name pattern for auto-created datasets. Supports variables: `workflow.runName`, `workflow.sessionId` (default: `\${workflow.runName}-outputs`).
+    """)
+    final String namePattern
+
+    @ConfigOption
+    @Description("""
+        Per-output dataset configuration. Each output can specify `datasetId` and `enabled` properties.
+    """)
+    final Map<String, Map> perOutput
+
+    DatasetConfig() {
+        this(Collections.emptyMap())
+    }
+
+    DatasetConfig(Map opts) {
+        this.enabled = opts.enabled != null ? opts.enabled as boolean : false
+        this.createMode = opts.createMode as String ?: 'auto'
+        this.namePattern = opts.namePattern as String ?: '${workflow.runName}-outputs'
+        this.perOutput = opts.perOutput as Map ?: Collections.emptyMap()
+    }
+
+    /**
+     * Get configuration for a specific output
+     *
+     * @param outputName The name of the workflow output
+     * @return Configuration map for the output, or empty map if not configured
+     */
+    Map getOutputConfig(String outputName) {
+        return perOutput?.get(outputName) as Map ?: Collections.emptyMap()
+    }
+
+    /**
+     * Check if dataset upload is enabled for a specific output
+     *
+     * @param outputName The name of the workflow output
+     * @return true if enabled, false otherwise
+     */
+    boolean isEnabledForOutput(String outputName) {
+        if (!enabled)
+            return false
+
+        final outputConfig = getOutputConfig(outputName)
+        if (outputConfig.containsKey('enabled'))
+            return outputConfig.enabled as boolean
+
+        return true
+    }
+
+    /**
+     * Get the dataset ID for a specific output, if configured
+     *
+     * @param outputName The name of the workflow output
+     * @return The dataset ID, or null if not configured
+     */
+    String getDatasetId(String outputName) {
+        final outputConfig = getOutputConfig(outputName)
+        return outputConfig.datasetId as String
+    }
+
+    /**
+     * Check if the configuration allows auto-creating datasets
+     *
+     * @return true if auto-create is enabled
+     */
+    boolean isAutoCreateEnabled() {
+        return createMode == 'auto'
+    }
+
+}

plugins/nf-tower/src/main/io/seqera/tower/plugin/TowerClient.groovy

@@ -35,11 +35,6 @@ import groovy.transform.TupleConstructor
 import groovy.util.logging.Slf4j
 import io.seqera.http.HxClient
 import io.seqera.util.trace.TraceUtils
-import io.seqera.tower.ApiClient
-import io.seqera.tower.ApiException
-import io.seqera.tower.api.DatasetsApi
-import io.seqera.tower.model.CreateDatasetRequest
-import io.seqera.tower.model.CreateDatasetResponse
 import nextflow.BuildInfo
 import nextflow.Session
 import nextflow.container.resolver.ContainerMeta
@@ -106,8 +101,6 @@ class TowerClient implements TraceObserverV2 {
 
     private HxClient httpClient
 
-    private DatasetsApi datasetsApi
-
     private JsonGenerator generator
 
     private String workflowId
@@ -164,7 +157,6 @@ class TowerClient implements TraceObserverV2 {
         this.schema = loadSchema()
         this.generator = TowerJsonGenerator.create(schema)
         this.reports = new TowerReports(session)
-        this.datasetsApi = createDatasetsApi()
     }
 
     TowerClient withEnvironment(Map env) {
@@ -177,30 +169,6 @@ class TowerClient implements TraceObserverV2 {
         this.generator = TowerJsonGenerator.create(Collections.EMPTY_MAP)
     }
 
-    /**
-     * Create and configure a DatasetsApi client for Seqera Platform
-     *
-     * @return Configured DatasetsApi instance
-     */
-    protected DatasetsApi createDatasetsApi() {
-        if( !accessToken || !endpoint ) {
-            return null
-        }
-
-        try {
-            def apiClient = new ApiClient()
-            apiClient.setBasePath(endpoint)
-            apiClient.setBearerToken(accessToken)
-            apiClient.setUserAgent("Nextflow/$BuildInfo.version")
-
-            return new DatasetsApi(apiClient)
-        }
-        catch( Exception e ) {
-            log.warn "Failed to initialize DatasetsApi: ${e.message}"
-            return null
-        }
-    }
-
     @Override
     boolean enableMetrics() { true }
 
@@ -298,6 +266,18 @@ class TowerClient implements TraceObserverV2 {
         return result
     }
 
+    protected String getUrlDatasets() {
+        if( workspaceId )
+            return "$endpoint/workspaces/$workspaceId/datasets/"
+        return "$endpoint/datasets/"
+    }
+
+    protected String getUrlDatasetUpload(String datasetId) {
+        if( workspaceId )
+            return "$endpoint/workspaces/$workspaceId/datasets/$datasetId/upload"
+        return "$endpoint/datasets/$datasetId/upload"
+    }
+
     /**
      * On workflow start, submit a message with some basic
      * information, like Id, activity and an ISO 8601 formatted
@@ -979,7 +959,7 @@ class TowerClient implements TraceObserverV2 {
     }
 
     /**
-     * Create a new dataset in Seqera Platform using tower-java-sdk
+     * Create a new dataset in Seqera Platform
      *
      * @param name The name for the new dataset
      * @param description The description for the new dataset
@@ -988,39 +968,40 @@ class TowerClient implements TraceObserverV2 {
     private String createDataset(String name, String description) {
         log.info "Creating new dataset: ${name}"
 
-        if( !datasetsApi ) {
-            log.warn "DatasetsApi not initialized, cannot create dataset"
-            return null
-        }
-
         try {
-            def request = new CreateDatasetRequest()
-            request.setName(name)
-            request.setDescription("Workflow output: ${description}")
-
-            def wspId = workspaceId ? Long.valueOf(workspaceId) : null
-            CreateDatasetResponse response = datasetsApi.createDataset(wspId, request)
+            final payload = [
+                name: name,
+                description: "Workflow output: ${description}",
+                header: true
+            ]
+
+            final url = getUrlDatasets()
+            final resp = sendHttpMessage(url, payload, 'POST')
+
+            if( resp.isError() ) {
+                log.warn "Failed to create dataset '${name}': ${resp.message}"
+                return null
+            }
 
-            def datasetId = response.dataset?.id?.toString()
+            // Parse the response to extract dataset ID
+            final json = new JsonSlurper().parseText(resp.message) as Map
+            final dataset = json.dataset as Map
+            final datasetId = dataset?.id as String
 
             if( datasetId ) {
                 log.info "Created dataset '${name}' with ID: ${datasetId}"
             }
 
             return datasetId
         }
-        catch( ApiException e ) {
-            log.warn "Failed to create dataset '${name}': ${e.message} (status: ${e.code})", e
-            return null
-        }
         catch( Exception e ) {
             log.warn "Failed to create dataset '${name}': ${e.message}", e
             return null
         }
     }
 
     /**
-     * Upload an index file to a dataset using tower-java-sdk
+     * Upload an index file to a dataset
      *
      * @param datasetId The ID of the dataset
      * @param indexPath The path to the index file
@@ -1032,27 +1013,95 @@ class TowerClient implements TraceObserverV2 {
             return
         }
 
-        if( !datasetsApi ) {
-            log.warn "DatasetsApi not initialized, cannot upload index file"
-            return
-        }
-
         log.info "Uploading index file for output '${outputName}' to dataset ${datasetId}: ${indexPath}"
 
         try {
-            def wspId = workspaceId ? Long.valueOf(workspaceId) : null
-            def header = Boolean.TRUE  // Workflow output index files always have headers
+            def url = getUrlDatasetUpload(datasetId)
+            // Workflow output index files always have headers
+            url += "?header=true"
 
-            datasetsApi.uploadDataset(wspId, datasetId, header, indexPath.toFile())
+            // Upload file using multipart form data
+            final resp = uploadFile(url, indexPath.toFile())
 
-            log.info "Successfully uploaded index file for output '${outputName}' to dataset ${datasetId}"
-        }
-        catch( ApiException e ) {
-            log.warn "Failed to upload index file for output '${outputName}': ${e.message} (status: ${e.code})", e
+            if( resp.isError() ) {
+                log.warn "Failed to upload index file for output '${outputName}': ${resp.message}"
+            } else {
+                log.info "Successfully uploaded index file for output '${outputName}' to dataset ${datasetId}"
+            }
         }
         catch( Exception e ) {
             log.warn "Failed to upload index file for output '${outputName}': ${e.message}", e
         }
     }
 
+    /**
+     * Upload a file to Seqera Platform using multipart/form-data
+     *
+     * @param url The upload URL
+     * @param file The file to upload
+     * @return Response object
+     */
+    protected Response uploadFile(String url, File file) {
+        log.trace "HTTP multipart upload: url=$url; file=${file.name}"
+
+        try {
+            // Create multipart body
+            final boundary = "----TowerNextflowBoundary" + System.currentTimeMillis()
+            final body = createMultipartBody(file, boundary)
+
+            // Build request
+            final request = HttpRequest.newBuilder(URI.create(url))
+                .header('Content-Type', "multipart/form-data; boundary=$boundary")
+                .header('User-Agent', "Nextflow/$BuildInfo.version")
+                .header('Traceparent', TraceUtils.rndTrace())
+                .POST(HttpRequest.BodyPublishers.ofByteArray(body))
+                .build()
+
+            final resp = httpClient.sendAsString(request)
+            final status = resp.statusCode()
+
+            if( status == 401 ) {
+                return new Response(status, 'Unauthorized Seqera Platform API access')
+            }
+            if( status >= 400 ) {
+                final msg = parseCause(resp?.body()) ?: "Unexpected response for request $url"
+                return new Response(status, msg as String)
+            }
+
+            return new Response(status, resp.body())
+        }
+        catch( IOException e ) {
+            return new Response(0, "Unable to connect to Seqera Platform API: ${getHostUrl(url)}")
+        }
+    }
+
+    /**
+     * Create a multipart/form-data request body
+     *
+     * @param file The file to include in the request
+     * @param boundary The multipart boundary string
+     * @return Byte array containing the multipart body
+     */
+    private byte[] createMultipartBody(File file, String boundary) {
+        final baos = new ByteArrayOutputStream()
+        final writer = new PrintWriter(new OutputStreamWriter(baos, 'UTF-8'), true)
+
+        // Write file part
+        writer.append("--${boundary}\r\n")
+        writer.append("Content-Disposition: form-data; name=\"file\"; filename=\"${file.name}\"\r\n")
+        writer.append("Content-Type: text/csv\r\n")
+        writer.append("\r\n")
+        writer.flush()
+
+        // Write file content
+        baos.write(file.bytes)
+
+        // Write closing boundary
+        writer.append("\r\n")
+        writer.append("--${boundary}--\r\n")
+        writer.flush()
+
+        return baos.toByteArray()
+    }
+
 }