fix(amazonq): hardcode amazon-internal glibc patch

Due to a quirk on how the internal glibc patch works,
remote desktop sessions do not automatically get the patch

therefore hardcode until this can be fixed internally

Author: rli

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/NodeExePatcher.kt

@@ -4,9 +4,12 @@
 package software.aws.toolkits.jetbrains.services.amazonq.lsp
 
 import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.util.system.CpuArch
+import software.aws.toolkits.core.utils.exists
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import java.nio.file.Path
+import java.nio.file.Paths
 
 /**
  * Hacky nonsense to support old glibc platforms like AL2
@@ -16,13 +19,14 @@ import java.nio.file.Path
 object NodeExePatcher {
     const val GLIBC_LINKER_VAR = "VSCODE_SERVER_CUSTOM_GLIBC_LINKER"
     const val GLIBC_PATH_VAR = "VSCODE_SERVER_CUSTOM_GLIBC_PATH"
+    const val INTERNAL_AARCH64_LINKER = "/opt/vsc-sysroot/lib/ld-linux-aarch64.so.1"
+    const val INTERNAL_X86_64_LINKER = "/opt/vsc-sysroot/lib/ld-linux-x86-64.so.2"
+    const val INTERNAL_GLIBC_PATH = "/opt/vsc-sysroot/lib/"
 
     fun patch(node: Path): GeneralCommandLine {
-        val linker = System.getenv(GLIBC_LINKER_VAR)
-        val glibc = System.getenv(GLIBC_PATH_VAR)
         val nodePath = node.toAbsolutePath().toString()
 
-        return if (!linker.isNullOrEmpty() && !glibc.isNullOrEmpty()) {
+        return if (Paths.get(linker).exists() && Paths.get(glibc).exists()) {
             GeneralCommandLine(linker)
                 .withParameters("--library-path", glibc, nodePath)
                 .also {
@@ -32,4 +36,16 @@ object NodeExePatcher {
             GeneralCommandLine(nodePath)
         }
     }
+
+    private val linker
+        get() = System.getenv(GLIBC_LINKER_VAR) ?: let {
+            if (CpuArch.isArm64()) {
+                INTERNAL_AARCH64_LINKER
+            } else {
+                INTERNAL_X86_64_LINKER
+            }
+        }
+
+    private val glibc
+        get() = System.getenv(GLIBC_PATH_VAR) ?: INTERNAL_GLIBC_PATH
 }

plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/NodeExePatcherTest.kt

@@ -4,31 +4,68 @@
 package software.aws.toolkits.jetbrains.services.amazonq.lsp
 
 import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.openapi.util.SystemInfo
+import com.intellij.testFramework.rules.TempDirectory
+import com.intellij.testFramework.utils.io.createDirectory
+import com.intellij.testFramework.utils.io.createFile
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.Assume.assumeTrue
 import org.junit.Rule
 import org.junit.Test
 import software.aws.toolkits.core.rules.EnvironmentVariableHelper
-import kotlin.io.path.Path
+import software.aws.toolkits.core.utils.exists
+import java.nio.file.Paths
 
 class NodeExePatcherTest {
     @get:Rule
     val envVarHelper = EnvironmentVariableHelper()
 
-    private val pathToNode = Path("/path/to/node").toAbsolutePath().toString()
+    @get:Rule
+    val tempDir = TempDirectory()
+
+    private val pathToNode = Paths.get("/path/to/node").toAbsolutePath().toString()
 
     @Test
-    fun `patches if path available`() {
-        envVarHelper[NodeExePatcher.GLIBC_LINKER_VAR] = "/opt/vsc-sysroot/lib/ld-linux-x86-64.so.2"
-        envVarHelper[NodeExePatcher.GLIBC_PATH_VAR] = "/opt/vsc-sysroot/lib/"
+    fun `patches if environment variables are available`() {
+        val path = tempDir.newDirectory("vsc-sysroot").toPath().toAbsolutePath()
+        val linker = Paths.get(path.toString(), "someSharedLibrary").createFile()
 
-        assertThat(NodeExePatcher.patch(Path("/path/to/node")))
+        envVarHelper[NodeExePatcher.GLIBC_LINKER_VAR] = linker.toString()
+        envVarHelper[NodeExePatcher.GLIBC_PATH_VAR] = path.toString()
+
+        assertThat(NodeExePatcher.patch(Paths.get("/path/to/node")))
             .usingComparator(Comparator.comparing { it.commandLineString })
-            .isEqualTo(GeneralCommandLine("/opt/vsc-sysroot/lib/ld-linux-x86-64.so.2", "--library-path", "/opt/vsc-sysroot/lib/", pathToNode))
+            .isEqualTo(GeneralCommandLine(linker.toString(), "--library-path", path.toString(), pathToNode))
+    }
+
+    @Test
+    fun `patches if hardcoded paths exists`() {
+        // explicitly linux because can't run on mac
+        assumeTrue(SystemInfo.isLinux)
+
+        val path = Paths.get(NodeExePatcher.INTERNAL_GLIBC_PATH)
+        val linker = Paths.get(NodeExePatcher.INTERNAL_X86_64_LINKER)
+        val needsCreate = !path.exists() && !linker.exists()
+        if (needsCreate) {
+            path.createDirectory()
+            linker.createFile()
+        }
+
+        try {
+            assertThat(NodeExePatcher.patch(Paths.get("/path/to/node")))
+                .usingComparator(Comparator.comparing { it.commandLineString })
+                .isEqualTo(GeneralCommandLine(linker.toString(), "--library-path", path.toString(), pathToNode))
+        } finally {
+            if (needsCreate) {
+                linker.toFile().delete()
+                path.toFile().deleteRecursively()
+            }
+        }
     }
 
     @Test
     fun `noop if no patch available`() {
-        assertThat(NodeExePatcher.patch(Path("/path/to/node")))
+        assertThat(NodeExePatcher.patch(Paths.get("/path/to/node")))
             .usingComparator(Comparator.comparing { it.commandLineString })
             .isEqualTo(GeneralCommandLine(pathToNode))
     }