Address Copilot review findings for FFI loader tests

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: edburns

java/src/main/java/com/github/copilot/ffi/NativeRuntimeLoader.java

@@ -24,8 +24,8 @@
  * <p>
  * Resolution order:
  * <ol>
- * <li>The {@code COPILOT_CLI_PATH} environment variable (if set, treated as the
- * resolved path and returned directly).</li>
+ * <li>The {@code COPILOT_RUNTIME_PATH} environment variable (if set, treated as
+ * the resolved {@code runtime.node} path and returned directly).</li>
  * <li>Classpath resource {@code native/<classifier>/runtime.node} extracted to
  * {@code ~/.copilot/runtime-cache/<version>/<classifier>/runtime.node}.</li>
  * <li>A {@code runtime.node} file alongside the bundled CLI binary.</li>
@@ -49,6 +49,8 @@ public final class NativeRuntimeLoader {
     private static final Logger LOG = Logger.getLogger(NativeRuntimeLoader.class.getName());
     private static final String PROPERTIES_RESOURCE = "copilot-runtime.properties";
     private static final String BINARY_NAME = "runtime.node";
+    private static final String RUNTIME_PATH_ENV = "COPILOT_RUNTIME_PATH";
+    private static final String CLI_PATH_ENV = "COPILOT_CLI_PATH";
 
     private NativeRuntimeLoader() {
     }
@@ -62,26 +64,30 @@ private NativeRuntimeLoader() {
      *             if the binary cannot be resolved, extracted, or cached
      */
     public static Path resolve() throws NativeRuntimeLoaderException {
-        // 1. COPILOT_CLI_PATH override
-        String cliPathEnv = System.getenv("COPILOT_CLI_PATH");
-        if (cliPathEnv != null && !cliPathEnv.isBlank()) {
-            return Paths.get(cliPathEnv);
+        return resolve(System.getenv(RUNTIME_PATH_ENV), System.getenv(CLI_PATH_ENV),
+                NativeRuntimeLoader.class.getClassLoader(), Paths.get(System.getProperty("user.home")),
+                PlatformDetector.detectClassifier());
+    }
+
+    static Path resolve(String runtimePathOverride, String bundledCliPath, ClassLoader classLoader, Path userHome,
+            String classifier) throws NativeRuntimeLoaderException {
+        // 1. Explicit runtime.node override
+        if (runtimePathOverride != null && !runtimePathOverride.isBlank()) {
+            return Paths.get(runtimePathOverride);
         }
 
         // 2. Extract from classpath resource
-        String version = loadVersion();
-        String classifier = PlatformDetector.detectClassifier();
         String resourcePath = "native/" + classifier + "/" + BINARY_NAME;
 
-        URL resourceUrl = NativeRuntimeLoader.class.getClassLoader().getResource(resourcePath);
+        URL resourceUrl = classLoader.getResource(resourcePath);
         if (resourceUrl != null) {
-            return extractToCache(resourceUrl, version, classifier);
+            String version = loadVersion(classLoader);
+            return extractToCache(resourceUrl, version, classifier, userHome);
         }
 
         // 3. Alongside bundled CLI (fall-through when no classpath resource)
-        String bundledCli = System.getenv("COPILOT_CLI_PATH");
-        if (bundledCli != null && !bundledCli.isBlank()) {
-            Path sibling = Paths.get(bundledCli).getParent();
+        if (bundledCliPath != null && !bundledCliPath.isBlank()) {
+            Path sibling = Paths.get(bundledCliPath).getParent();
             if (sibling != null) {
                 Path candidate = sibling.resolve(BINARY_NAME);
                 if (isValidCacheEntry(candidate)) {
@@ -103,7 +109,11 @@ public static Path resolve() throws NativeRuntimeLoaderException {
      *             if the resource is missing or the version value is blank
      */
     static String loadVersion() throws NativeRuntimeLoaderException {
-        InputStream in = NativeRuntimeLoader.class.getClassLoader().getResourceAsStream(PROPERTIES_RESOURCE);
+        return loadVersion(NativeRuntimeLoader.class.getClassLoader());
+    }
+
+    static String loadVersion(ClassLoader classLoader) throws NativeRuntimeLoaderException {
+        InputStream in = classLoader.getResourceAsStream(PROPERTIES_RESOURCE);
         if (in == null) {
             throw new NativeRuntimeLoaderException("Missing classpath resource: " + PROPERTIES_RESOURCE
                     + ". Ensure the SDK JAR was built with Maven resource filtering enabled.");
@@ -123,9 +133,9 @@ static String loadVersion() throws NativeRuntimeLoaderException {
         return version.trim();
     }
 
-    private static Path extractToCache(URL resourceUrl, String version, String classifier)
+    static Path extractToCache(URL resourceUrl, String version, String classifier, Path userHome)
             throws NativeRuntimeLoaderException {
-        Path cacheDir = Paths.get(System.getProperty("user.home"), ".copilot", "runtime-cache", version, classifier);
+        Path cacheDir = userHome.resolve(Paths.get(".copilot", "runtime-cache", version, classifier));
         Path cached = cacheDir.resolve(BINARY_NAME);
 
         // 1. Cache hit: regular, non-empty file

java/src/main/java/com/github/copilot/ffi/PlatformDetector.java

@@ -151,15 +151,19 @@ public static LinuxLibc detectLinuxLibc() {
      *             if the platform is not recognised or not supported
      */
     public static String detectClassifier() {
-        String os = detectOs();
-        String arch = detectArch();
-        if (!"linux".equals(os)) {
-            String classifier = os + "-" + arch;
-            validateClassifier(classifier);
-            return classifier;
+        return detectClassifier(System.getProperty("os.name", ""), System.getProperty("os.arch", ""),
+                detectLinuxLibc());
+    }
+
+    static String detectClassifier(String osName, String osArch, LinuxLibc linuxLibc) {
+        String os = detectOs(osName);
+        String arch = detectArch(osArch);
+        String classifier;
+        if ("linux".equals(os)) {
+            classifier = (linuxLibc == LinuxLibc.MUSL ? "linuxmusl-" : "linux-") + arch;
+        } else {
+            classifier = os + "-" + arch;
         }
-        LinuxLibc libc = detectLinuxLibc();
-        String classifier = (libc == LinuxLibc.MUSL ? "linuxmusl-" : "linux-") + arch;
         validateClassifier(classifier);
         return classifier;
     }
@@ -230,16 +234,22 @@ static String readElfPtInterp(Path executablePath) throws IOException {
         if (phentsize <= 0 || phnum <= 0) {
             throw new IOException("Invalid ELF program header metadata: phentsize=" + phentsize + ", phnum=" + phnum);
         }
+        int minProgramHeaderSize = elfClass == ELF_CLASS_64 ? 56 : 32;
+        if (phentsize < minProgramHeaderSize) {
+            throw new IOException("Invalid ELF program header entry size: " + phentsize + " (expected >= "
+                    + minProgramHeaderSize + ")");
+        }
 
         for (int i = 0; i < phnum; i++) {
             long baseLong = phoff + ((long) i * phentsize);
             if (baseLong < 0 || baseLong > Integer.MAX_VALUE) {
                 break;
             }
-            int base = (int) baseLong;
-            if (base + phentsize > size) {
+            long entryEnd = baseLong + phentsize;
+            if (entryEnd > size) {
                 break;
             }
+            int base = (int) baseLong;
 
             long pType = readUInt32(probe, base, littleEndian);
             if (pType != PT_INTERP) {
@@ -260,11 +270,12 @@ static String readElfPtInterp(Path executablePath) throws IOException {
                 throw new IOException("Invalid PT_INTERP bounds");
             }
 
-            int start = (int) pOffset;
-            int end = start + (int) pFileSize;
-            if (end > size) {
+            long endLong = pOffset + pFileSize;
+            if (endLong > size || endLong > Integer.MAX_VALUE || endLong <= pOffset) {
                 throw new IOException("PT_INTERP extends past probe window; increase probe size");
             }
+            int start = (int) pOffset;
+            int end = (int) endLong;
 
             int nulIndex = start;
             while (nulIndex < end && probe[nulIndex] != 0) {