New nextflow auth status command

Signed-off-by: Phil Ewels <[email protected]>

Author: ewels

modules/nextflow/src/main/groovy/nextflow/cli/CmdAuth.groovy

@@ -66,6 +66,7 @@ class CmdAuth extends CmdBase implements UsageAware {
         commands.add(new LoginCmd())
         commands.add(new LogoutCmd())
         commands.add(new ConfigCmd())
+        commands.add(new StatusCmd())
     }
 
     void usage() {
@@ -1019,4 +1020,172 @@ class CmdAuth extends CmdBase implements UsageAware {
             result << ''
         }
     }
+
+    class StatusCmd implements SubCmd {
+
+        @Override
+        String getName() { 'status' }
+
+        @Override
+        void apply(List<String> args) {
+            if (args.size() > 0) {
+                throw new AbortOperationException("Too many arguments for status command")
+            }
+
+            def config = readConfig()
+
+            println "Nextflow Seqera Platform authentication status"
+            println ""
+
+            // API endpoint
+            def endpointInfo = getConfigValue(config, 'tower.endpoint', 'TOWER_API_ENDPOINT', 'https://api.cloud.seqera.io')
+            println "API endpoint: ${endpointInfo.value} (${endpointInfo.source})"
+
+            // Access token status
+            def tokenInfo = getConfigValue(config, 'tower.accessToken', 'TOWER_ACCESS_TOKEN')
+            if (tokenInfo.value) {
+                println "Access token: yes (${tokenInfo.source})"
+            } else {
+                println "Access token: no"
+            }
+
+            // Monitoring enabled
+            def enabledInfo = getConfigValue(config, 'tower.enabled', null, 'false')
+            def enabledValue = enabledInfo.value?.toString()?.toLowerCase() in ['true', '1', 'yes'] ? 'Yes' : 'No'
+            println "Local workflow monitoring enabled: ${enabledValue} (${enabledInfo.source ?: 'default'})"
+
+            // Default workspace
+            def workspaceInfo = getConfigValue(config, 'tower.workspaceId', 'TOWER_WORKFLOW_ID')
+            if (workspaceInfo.value) {
+                // Try to get workspace name from API if we have a token
+                def workspaceName = null
+                if (tokenInfo.value) {
+                    workspaceName = getWorkspaceNameFromApi(tokenInfo.value as String, endpointInfo.value as String, workspaceInfo.value as String)
+                }
+
+                if (workspaceName) {
+                    println "Default workspace: ${workspaceName} [${workspaceInfo.value}] (${workspaceInfo.source})"
+                } else {
+                    println "Default workspace: ${workspaceInfo.value} (${workspaceInfo.source})"
+                }
+            } else {
+                println "Default workspace: Personal workspace (default)"
+            }
+
+            println ""
+            println "System health status"
+
+            // API connection check
+            def apiConnectionOk = checkApiConnection(endpointInfo.value as String)
+            println "API connection: ${apiConnectionOk ? 'OK' : 'ERROR'}"
+
+            // Authentication check
+            if (tokenInfo.value) {
+                try {
+                    def userInfo = callUserInfoApi(tokenInfo.value as String, endpointInfo.value as String)
+                    def currentUser = userInfo.userName
+                    println "Authentication: OK (${currentUser})"
+                } catch (Exception e) {
+                    println "Authentication: ERROR"
+                }
+            } else {
+                println "Authentication: ERROR (no token)"
+            }
+        }
+
+        private String shortenPath(String path) {
+            def userHome = System.getProperty('user.home')
+            if (path.startsWith(userHome)) {
+                return '~' + path.substring(userHome.length())
+            }
+            return path
+        }
+
+        private Map getConfigValue(Map config, String configKey, String envVarName, String defaultValue = null) {
+            def configValue = config[configKey]
+            def envValue = System.getenv(envVarName)
+            def effectiveValue = configValue ?: envValue ?: defaultValue
+
+            def source = null
+            if (configValue) {
+                source = shortenPath(getConfigFile().toString())
+            } else if (envValue) {
+                source = "env var \$${envVarName}"
+            } else if (defaultValue) {
+                source = "default"
+            }
+
+            return [
+                value: effectiveValue,
+                source: source,
+                fromConfig: configValue != null,
+                fromEnv: envValue != null,
+                isDefault: !configValue && !envValue
+            ]
+        }
+
+        private String getWorkspaceNameFromApi(String accessToken, String endpoint, String workspaceId) {
+            try {
+                // Get user info to get user ID
+                def userInfo = callUserInfoApi(accessToken, endpoint)
+                def userId = userInfo.id as String
+
+                // Get workspaces for the user
+                def workspacesUrl = "${endpoint}/user/${userId}/workspaces"
+                def connection = new URL(workspacesUrl).openConnection() as HttpURLConnection
+                connection.requestMethod = 'GET'
+                connection.connectTimeout = 10000 // 10 second timeout
+                connection.readTimeout = 10000
+                connection.setRequestProperty('Authorization', "Bearer ${accessToken}")
+
+                if (connection.responseCode != 200) {
+                    return null
+                }
+
+                def response = connection.inputStream.text
+                def json = new groovy.json.JsonSlurper().parseText(response) as Map
+                def orgsAndWorkspaces = json.orgsAndWorkspaces as List
+
+                // Find the workspace with matching ID
+                def workspace = orgsAndWorkspaces.find { ((Map)it).workspaceId?.toString() == workspaceId }
+                if (workspace) {
+                    def ws = workspace as Map
+                    return "${ws.orgName} / ${ws.workspaceFullName}"
+                }
+
+                return null
+            } catch (Exception e) {
+                return null
+            }
+        }
+
+        private boolean checkApiConnection(String endpoint) {
+            try {
+                def serviceInfoUrl = "${endpoint}/service-info"
+                def connection = new URL(serviceInfoUrl).openConnection() as HttpURLConnection
+                connection.requestMethod = 'GET'
+                connection.connectTimeout = 10000 // 10 second timeout
+                connection.readTimeout = 10000
+
+                return connection.responseCode == 200
+            } catch (Exception e) {
+                return false
+            }
+        }
+
+
+        @Override
+        void usage(List<String> result) {
+            result << 'Show authentication status and configuration'
+            result << "Usage: nextflow auth $name".toString()
+            result << ''
+            result << 'This command shows:'
+            result << '  - Authentication status (yes/no) and source'
+            result << '  - API endpoint and source'
+            result << '  - Monitoring enabled status and source'
+            result << '  - Default workspace and source'
+            result << '  - System health status (API connection and authentication)'
+            result << ''
+        }
+    }
 }