Version segregate jetbrains-ultimate files for 2025.3

- CodeCatalystGatewayClientCustomizer: GatewayClientCustomizationProvider API removed
- DevEnvStatusWatcher: UnattendedStatusUtil API removed, use fallback values
- GoHelper: Go debugger APIs changed, throw UnsupportedOperationException
- NodeJsDebugSupport: NodeJS debugger APIs changed, stub implementation

src-242-252: Original working implementations
src-253+: Stubbed/disabled implementations with TODOs

Author: aseemxs

plugins/toolkit/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/remoteDev/caws/CodeCatalystGatewayClientCustomizer.kt renamed to plugins/toolkit/jetbrains-ultimate/src-242-252/software/aws/toolkits/jetbrains/remoteDev/caws/CodeCatalystGatewayClientCustomizer.kt

@@ -0,0 +1,25 @@
+// Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.remoteDev.caws
+
+// TODO: GatewayClientCustomizationProvider removed in 2025.3 - investigate new Gateway customization APIs
+/*
+import com.intellij.openapi.extensions.ExtensionNotApplicableException
+import com.jetbrains.rdserver.unattendedHost.customization.controlCenter.GatewayClientCustomizationProvider
+import icons.AwsIcons
+import software.aws.toolkits.jetbrains.utils.isCodeCatalystDevEnv
+import software.aws.toolkits.resources.message
+
+class CodeCatalystGatewayClientCustomizer : GatewayClientCustomizationProvider {
+    init {
+        if (!isCodeCatalystDevEnv()) {
+            throw ExtensionNotApplicableException.create()
+        }
+    }
+
+    override fun getIcon() = AwsIcons.Logos.AWS_SMILE_SMALL
+
+    override fun getTitle() = message("caws.gateway.title")
+}
+*/

plugins/toolkit/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/remoteDev/caws/DevEnvStatusWatcher.kt renamed to plugins/toolkit/jetbrains-ultimate/src-242-252/software/aws/toolkits/jetbrains/remoteDev/caws/DevEnvStatusWatcher.kt

@@ -0,0 +1,140 @@
+// Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.remoteDev.caws
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.startup.StartupActivity
+import com.intellij.openapi.ui.MessageDialogBuilder
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import software.amazon.awssdk.services.codecatalyst.CodeCatalystClient
+import software.aws.toolkits.core.utils.error
+import software.aws.toolkits.core.utils.getLogger
+import software.aws.toolkits.core.utils.info
+import software.aws.toolkits.jetbrains.core.awsClient
+import software.aws.toolkits.jetbrains.core.coroutines.getCoroutineBgContext
+import software.aws.toolkits.jetbrains.core.coroutines.getCoroutineUiContext
+import software.aws.toolkits.jetbrains.core.coroutines.projectCoroutineScope
+import software.aws.toolkits.jetbrains.core.credentials.sono.CodeCatalystCredentialManager
+import software.aws.toolkits.jetbrains.services.caws.CawsConstants
+import software.aws.toolkits.jetbrains.services.caws.envclient.CawsEnvironmentClient
+import software.aws.toolkits.jetbrains.services.caws.envclient.models.UpdateActivityRequest
+import software.aws.toolkits.jetbrains.utils.isCodeCatalystDevEnv
+import software.aws.toolkits.jetbrains.utils.notifyError
+import software.aws.toolkits.resources.message
+import java.time.Instant
+import java.time.temporal.ChronoUnit
+
+class DevEnvStatusWatcher : StartupActivity {
+
+    companion object {
+        private val LOG = getLogger<DevEnvStatusWatcher>()
+    }
+
+    override fun runActivity(project: Project) {
+        if (!isCodeCatalystDevEnv()) {
+            return
+        }
+        val connection = CodeCatalystCredentialManager.getInstance(project).getConnectionSettings()
+            ?: error("Failed to fetch connection settings from Dev Environment")
+        val envId = System.getenv(CawsConstants.CAWS_ENV_ID_VAR) ?: error("envId env var null")
+        val org = System.getenv(CawsConstants.CAWS_ENV_ORG_NAME_VAR) ?: error("space env var null")
+        val projectName = System.getenv(CawsConstants.CAWS_ENV_PROJECT_NAME_VAR) ?: error("project env var null")
+        val client = connection.awsClient<CodeCatalystClient>()
+        val coroutineScope = projectCoroutineScope(project)
+        coroutineScope.launch(getCoroutineBgContext()) {
+            val initialEnv = client.getDevEnvironment {
+                it.id(envId)
+                it.spaceName(org)
+                it.projectName(projectName)
+            }
+            val inactivityTimeout = initialEnv.inactivityTimeoutMinutes()
+            if (inactivityTimeout == 0) {
+                LOG.info { "Dev environment inactivity timeout is 0, not monitoring" }
+                return@launch
+            }
+            val inactivityTimeoutInSeconds = inactivityTimeout * 60
+
+            // TODO: Re-enable when Gateway APIs are available in 2025.3
+            // val jbActivityStatus = GatewayConnectionUtil.getInstance().getSecondsSinceLastControllerActivity()
+            val jbActivityStatus = 0L // Temporary fallback
+            notifyBackendOfActivity((getActivityTime(jbActivityStatus).toString()))
+            var secondsSinceLastControllerActivity = jbActivityStatus
+
+            while (true) {
+                val response = checkHeartbeat(secondsSinceLastControllerActivity, inactivityTimeoutInSeconds, project)
+                if (response.first) return@launch
+                delay(30000)
+                secondsSinceLastControllerActivity = response.second
+            }
+        }
+    }
+
+    // This function returns a Pair The first value is a boolean indicating if the API returned the last recorded activity.
+    // If inactivity tracking is disabled or if the value returned by the API is unparseable, the heartbeat is not sent
+    // The second value indicates the seconds since last activity as recorded by JB in the most recent run
+    fun checkHeartbeat(
+        secondsSinceLastControllerActivity: Long,
+        inactivityTimeoutInSeconds: Int,
+        project: Project,
+    ): Pair<Boolean, Long> {
+        val lastActivityTime = getJbRecordedActivity()
+
+        if (lastActivityTime < secondsSinceLastControllerActivity) {
+            // update the API in case of any activity
+            notifyBackendOfActivity((getActivityTime(lastActivityTime).toString()))
+        }
+
+        val lastRecordedActivityTime = getLastRecordedApiActivity()
+        if (lastRecordedActivityTime == null) {
+            LOG.error { "Couldn't retrieve last recorded activity from API" }
+            return Pair(true, lastActivityTime)
+        }
+        val durationRecordedSinceLastActivity = Instant.now().toEpochMilli().minus(lastRecordedActivityTime.toLong())
+        val secondsRecordedSinceLastActivity = durationRecordedSinceLastActivity / 1000
+
+        if (secondsRecordedSinceLastActivity >= (inactivityTimeoutInSeconds - 300)) {
+            try {
+                val inactivityDurationInMinutes = secondsRecordedSinceLastActivity / 60
+                val ans = runBlocking {
+                    val continueWorking = withContext(getCoroutineUiContext()) {
+                        return@withContext MessageDialogBuilder.okCancel(
+                            message("caws.devenv.continue.working.after.timeout.title"),
+                            message("caws.devenv.continue.working.after.timeout", inactivityDurationInMinutes)
+                        ).ask(project)
+                    }
+                    return@runBlocking continueWorking
+                }
+
+                if (ans) {
+                    notifyBackendOfActivity(getActivityTime().toString())
+                }
+            } catch (e: Exception) {
+                val preMessage = "Error while checking if Dev Environment should continue working"
+                LOG.error(e) { preMessage }
+                notifyError(preMessage, e.message.toString())
+            }
+        }
+        return Pair(false, lastActivityTime)
+    }
+
+    fun getLastRecordedApiActivity(): String? = CawsEnvironmentClient.getInstance().getActivity()?.timestamp
+
+    // TODO: Re-enable when Gateway APIs are available in 2025.3
+    // Original: GatewayConnectionUtil.getInstance().getSecondsSinceLastControllerActivity()
+    private val fallbackActivityTime = 0L
+
+    fun getJbRecordedActivity(): Long = fallbackActivityTime
+
+    fun notifyBackendOfActivity(timestamp: String = Instant.now().toEpochMilli().toString()) {
+        val request = UpdateActivityRequest(
+            timestamp = timestamp
+        )
+        CawsEnvironmentClient.getInstance().putActivityTimestamp(request)
+    }
+
+    private fun getActivityTime(secondsSinceLastActivity: Long = 0): Long = Instant.now().minus(secondsSinceLastActivity, ChronoUnit.SECONDS).toEpochMilli()
+}

plugins/toolkit/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/services/lambda/go/GoHelper.kt renamed to plugins/toolkit/jetbrains-ultimate/src-242-252/software/aws/toolkits/jetbrains/services/lambda/go/GoHelper.kt

@@ -0,0 +1,74 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.lambda.go
+
+// TODO: Re-enable when Go plugin APIs are available in 2025.3
+// import com.goide.dlv.DlvDebugProcessUtil
+import com.goide.execution.GoRunUtil
+import com.intellij.openapi.application.runReadAction
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectFileIndex
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.xdebugger.XDebugProcess
+import com.intellij.xdebugger.XDebugProcessStarter
+import com.intellij.xdebugger.XDebugSession
+import software.aws.toolkits.jetbrains.utils.execution.steps.Context
+import java.nio.file.Files
+
+/**
+ * "Light" ides like Goland do not rely on marking folders as source root, so infer it based on
+ * the go.mod file. This function is based off of the similar PackageJsonUtil#findUpPackageJson
+ *
+ * @throws IllegalStateException If the contentRoot cannot be located
+ */
+fun inferSourceRoot(project: Project, virtualFile: VirtualFile): VirtualFile? {
+    val projectFileIndex = ProjectFileIndex.getInstance(project)
+    val contentRoot = runReadAction {
+        projectFileIndex.getContentRootForFile(virtualFile)
+    }
+
+    return contentRoot?.let { root ->
+        var file = virtualFile.parent
+        while (file != null) {
+            if ((file.isDirectory && file.children.any { !it.isDirectory && it.name == "go.mod" })) {
+                return file
+            }
+            // If we go up to the root and it's still not found, stop going up and mark source root as
+            // not found, since it will fail to build
+            if (file == root) {
+                return null
+            }
+            file = file.parent
+        }
+        return null
+    }
+}
+
+object GoDebugHelper {
+    // TODO see https://youtrack.jetbrains.com/issue/GO-10775 for "Debugger disconnected unexpectedly" when the lambda finishes
+    fun createGoDebugProcess(
+        @Suppress("UNUSED_PARAMETER") debugHost: String,
+        @Suppress("UNUSED_PARAMETER") debugPorts: List<Int>,
+        @Suppress("UNUSED_PARAMETER") context: Context,
+    ): XDebugProcessStarter = object : XDebugProcessStarter() {
+        override fun start(session: XDebugSession): XDebugProcess {
+            // TODO: Re-enable when Go plugin APIs are available in 2025.3
+            // val process = DlvDebugProcessUtil.createDlvDebugProcess(session, DlvDisconnectOption.KILL, null, true)
+            throw UnsupportedOperationException("Go debugging temporarily disabled in 2025.3 - Go plugin APIs moved")
+        }
+    }
+
+    fun copyDlv(): String {
+        // This can take a target platform, but that pulls directly from GOOS, so we have to walk back up the file tree
+        // either way. Goland comes with mac/window/linux dlv since it supports remote debugging, so it is always safe to
+        // pull the linux one
+        val dlvFolder = GoRunUtil.getBundledDlv(null)?.parentFile?.parentFile?.resolve("linux")
+            ?: throw IllegalStateException("Packaged Devle debugger is not found!")
+        val directory = Files.createTempDirectory("goDebugger")
+        Files.copy(dlvFolder.resolve("dlv").toPath(), directory.resolve("dlv"))
+        // Delve that comes packaged with the IDE does not have the executable flag set
+        directory.resolve("dlv").toFile().setExecutable(true)
+        return directory.toAbsolutePath().toString()
+    }
+}

plugins/toolkit/jetbrains-ultimate/src/software/aws/toolkits/jetbrains/services/lambda/nodejs/NodeJsDebugSupport.kt renamed to plugins/toolkit/jetbrains-ultimate/src-242-252/software/aws/toolkits/jetbrains/services/lambda/nodejs/NodeJsDebugSupport.kt

@@ -0,0 +1,128 @@
+// Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.lambda.nodejs
+
+import com.google.common.collect.BiMap
+import com.google.common.collect.HashBiMap
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.execution.ui.ExecutionConsole
+import com.intellij.javascript.debugger.LocalFileSystemFileFinder
+import com.intellij.javascript.debugger.RemoteDebuggingFileFinder
+import com.intellij.openapi.fileTypes.FileType
+import com.intellij.openapi.fileTypes.PlainTextFileType
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.xdebugger.XDebugProcess
+import com.intellij.xdebugger.XDebugProcessStarter
+import com.intellij.xdebugger.XDebugSession
+import com.intellij.xdebugger.evaluation.XDebuggerEditorsProviderBase
+import compat.com.intellij.lang.javascript.JavascriptLanguage
+import org.jetbrains.io.LocalFileFinder
+import software.aws.toolkits.core.lambda.LambdaRuntime
+import software.aws.toolkits.jetbrains.services.PathMapping
+import software.aws.toolkits.jetbrains.services.lambda.execution.sam.ImageDebugSupport
+import software.aws.toolkits.jetbrains.services.lambda.execution.sam.RuntimeDebugSupport
+import software.aws.toolkits.jetbrains.services.lambda.execution.sam.SamRunningState
+import software.aws.toolkits.jetbrains.utils.execution.steps.Context
+import javax.swing.JComponent
+import javax.swing.JLabel
+
+class NodeJsRuntimeDebugSupport : RuntimeDebugSupport {
+    override suspend fun createDebugProcess(
+        context: Context,
+        environment: ExecutionEnvironment,
+        state: SamRunningState,
+        debugHost: String,
+        debugPorts: List<Int>,
+    ): XDebugProcessStarter = NodeJsDebugUtils.createDebugProcess(state, debugHost, debugPorts)
+}
+
+abstract class NodeJsImageDebugSupport : ImageDebugSupport {
+    override fun supportsPathMappings(): Boolean = true
+    override val languageId = JavascriptLanguage.id
+    override suspend fun createDebugProcess(
+        context: Context,
+        environment: ExecutionEnvironment,
+        state: SamRunningState,
+        debugHost: String,
+        debugPorts: List<Int>,
+    ): XDebugProcessStarter = NodeJsDebugUtils.createDebugProcess(state, debugHost, debugPorts)
+
+    override fun containerEnvVars(debugPorts: List<Int>): Map<String, String> = mapOf(
+        "NODE_OPTIONS" to "--inspect-brk=0.0.0.0:${debugPorts.first()} --max-http-header-size 81920"
+    )
+}
+
+class NodeJs16ImageDebug : NodeJsImageDebugSupport() {
+    override val id: String = LambdaRuntime.NODEJS16_X.toString()
+    override fun displayName() = LambdaRuntime.NODEJS16_X.toString().capitalize()
+}
+
+class NodeJs18ImageDebug : NodeJsImageDebugSupport() {
+    override val id: String = LambdaRuntime.NODEJS18_X.toString()
+    override fun displayName() = LambdaRuntime.NODEJS18_X.toString().capitalize()
+}
+
+class NodeJs20ImageDebug : NodeJsImageDebugSupport() {
+    override val id: String = LambdaRuntime.NODEJS20_X.toString()
+    override fun displayName() = LambdaRuntime.NODEJS20_X.toString().capitalize()
+}
+
+object NodeJsDebugUtils {
+    private const val NODE_MODULES = "node_modules"
+
+    // Noop editors provider for disabled NodeJS debugging in 2025.3
+    private class NoopXDebuggerEditorsProvider : XDebuggerEditorsProviderBase() {
+        override fun getFileType(): FileType = PlainTextFileType.INSTANCE
+        override fun createExpressionCodeFragment(project: Project, text: String, context: PsiElement?, isPhysical: Boolean): PsiFile? = null
+    }
+
+    fun createDebugProcess(
+        state: SamRunningState,
+        @Suppress("UNUSED_PARAMETER") debugHost: String,
+        @Suppress("UNUSED_PARAMETER") debugPorts: List<Int>,
+    ): XDebugProcessStarter = object : XDebugProcessStarter() {
+        override fun start(session: XDebugSession): XDebugProcess {
+            val mappings = createBiMapMappings(state.pathMappings)
+
+            @Suppress("UNUSED_VARIABLE")
+            val fileFinder = RemoteDebuggingFileFinder(mappings, LocalFileSystemFileFinder())
+
+            // STUB IMPLEMENTATION: NodeJS debugging temporarily disabled
+            return object : XDebugProcess(session) {
+                override fun getEditorsProvider() = NoopXDebuggerEditorsProvider()
+                override fun doGetProcessHandler() = null
+                override fun createConsole() = object : ExecutionConsole {
+                    override fun getComponent(): JComponent = JLabel("NodeJS debugging disabled in 2025.3")
+                    override fun getPreferredFocusableComponent(): JComponent? = null
+                    override fun dispose() {}
+                }
+            }
+        }
+    }
+
+    /**
+     * Convert [PathMapping] to NodeJs debugger path mapping format.
+     *
+     * Docker uses the same project structure for dependencies in the folder node_modules. We map the source code and
+     * the dependencies in node_modules folder separately as the node_modules might not exist in the local project.
+     */
+    private fun createBiMapMappings(pathMapping: List<PathMapping>): BiMap<String, VirtualFile> {
+        val mappings = HashBiMap.create<String, VirtualFile>(pathMapping.size)
+
+        listOf(".", NODE_MODULES).forEach { subPath ->
+            pathMapping.forEach {
+                val remotePath = FileUtil.toCanonicalPath("${it.remoteRoot}/$subPath")
+                LocalFileFinder.findFile("${it.localRoot}/$subPath")?.let { localFile ->
+                    mappings.putIfAbsent("file://$remotePath", localFile)
+                }
+            }
+        }
+
+        return mappings
+    }
+}