Binary detection

Author: Explosion-Scratch

lib/installer.js

@@ -18,6 +18,7 @@ const {
   selectBestAsset,
   extractArchive,
   getBinaries,
+  selectBinaries,
   processExtractedPackages,
   installApp,
   installPkg,
@@ -641,7 +642,7 @@ const installSelected = async (selected, downloadPath, log) => {
         const mountDir = path.join(tmpdir, "dmg-mount");
         fs.mkdirSync(mountDir, { recursive: true });
         mountDMG(downloadPath, mountDir, log);
-        const dmgBinaries = getBinaries(mountDir);
+        let dmgBinaries = getBinaries(mountDir);
         log.debug(
           `Found ${dmgBinaries.length} items in DMG: ${dmgBinaries.join(", ")}`,
         );
@@ -667,15 +668,16 @@ const installSelected = async (selected, downloadPath, log) => {
           log.log(
             "No .app or .pkg found in DMG, trying to install executables",
           );
+          const selectedBinaries = await selectBinaries(dmgBinaries, selected.name, log);
           destinations = await installBinaries(
-            dmgBinaries,
+            selectedBinaries,
             mountDir,
             selected.name,
             checkPath,
             log,
             true, // isMountedVolume = true
           );
-          binariesList = dmgBinaries.map((bin) => path.basename(bin));
+          binariesList = selectedBinaries.map((bin) => path.basename(bin));
         } else {
           throw new Error("No installable files found in DMG");
         }
@@ -750,14 +752,15 @@ const installSelected = async (selected, downloadPath, log) => {
         }
       } else {
         // Fall back to regular binary installation
+        const selectedBinaries = await selectBinaries(extractedBinaries, selected.name, log);
         destinations = await installBinaries(
-          extractedBinaries,
+          selectedBinaries,
           outputDir,
           selected.name,
           checkPath,
           log,
         );
-        binariesList = extractedBinaries.map((bin) => path.basename(bin));
+        binariesList = selectedBinaries.map((bin) => path.basename(bin));
       }
       break;
   }

lib/installers.js

@@ -245,19 +245,135 @@ const getBinaries = (dir) => {
       if (appDirectories.some((app) => f.startsWith(app + "/"))) {
         return false;
       }
-      return execSync(`file ${JSON.stringify(path.resolve(dir, f))}`).includes(
-        "executable"
-      );
+      
+      const filePath = path.resolve(dir, f);
+      const fileOutput = execSync(`file ${JSON.stringify(filePath)}`).toString();
+      
+      // Check if it's an executable binary or script
+      return fileOutput.includes("executable") || 
+             fileOutput.includes("ELF") || 
+             fileOutput.includes("Mach-O") ||
+             fileOutput.includes("script");
     } catch {
       return false;
     }
   };
 
-  binaries.push(...allFiles.filter(isExecutable));
+  // Also check for files that look like binaries based on naming patterns
+  const looksLikeBinary = (f) => {
+    const filename = path.basename(f).toLowerCase();
+    const dirname = path.dirname(f).toLowerCase();
+    
+    // Skip files in common non-binary directories
+    if (dirname.includes("doc") || dirname.includes("docs") || dirname.includes("man") || 
+        dirname.includes("runtime") || dirname.includes("lib") || dirname.includes("share")) {
+      return false;
+    }
+    
+    // Skip obvious non-binary files
+    if (filename.includes("readme") || filename.includes("license") || 
+        filename.includes("changelog") || filename.includes("copying") ||
+        filename.includes("install") || filename.includes("makefile") ||
+        filename.includes(".md") || filename.includes(".txt") || 
+        filename.includes(".1") || filename.includes(".json") ||
+        filename.includes(".yaml") || filename.includes(".yml") ||
+        filename.includes(".toml") || filename.includes(".cfg") ||
+        filename.includes(".conf") || filename.includes(".ini")) {
+      return false;
+    }
+    
+    // Common binary naming patterns
+    const binaryPatterns = [
+      /^[a-z0-9_-]+$/,  // Simple name like hx, git, node
+      /^[a-z0-9_-]+\.(exe|bin|run)$/,  // Extensions
+    ];
+    
+    return binaryPatterns.some(pattern => pattern.test(filename));
+  };
+
+  const executableFiles = allFiles.filter(isExecutable);
+  const potentialBinaries = allFiles.filter(looksLikeBinary);
+  
+  // Combine and remove duplicates
+  binaries.push(...executableFiles);
+  binaries.push(...potentialBinaries.filter(f => !executableFiles.includes(f)));
 
   return [...new Set(binaries)]; // Remove duplicates
 };
 
+/**
+ * Prompt user to choose from multiple binaries found in a package
+ * @param {string[]} binaries - List of binary files found
+ * @param {string} packageName - Name of the package being installed
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<string[]>} Selected binaries
+ */
+const selectBinaries = async (binaries, packageName, logger = null) => {
+  if (binaries.length <= 1) {
+    return binaries;
+  }
+
+  // Filter out obvious non-binaries for cleaner selection
+  const filteredBinaries = binaries.filter(f => {
+    const filename = path.basename(f).toLowerCase();
+    return !filename.includes('readme') && 
+           !filename.includes('license') && 
+           !filename.includes('changelog') &&
+           !filename.includes('.md') &&
+           !filename.includes('.txt') &&
+           !filename.includes('.1') && // man pages
+           !f.includes('doc/') &&
+           !f.includes('docs/') &&
+           !f.includes('man/');
+  });
+
+  // If filtering leaves us with just one, use it
+  if (filteredBinaries.length === 1) {
+    if (logger) {
+      logger.log(`Auto-selected binary: ${filteredBinaries[0]}`);
+    }
+    return filteredBinaries;
+  }
+
+  // If filtering leaves none, fall back to original list
+  const binariesToChoose = filteredBinaries.length > 0 ? filteredBinaries : binaries;
+
+  if (logger) {
+    logger.log(`Multiple binaries found in ${packageName}. Please choose which to install:`);
+    binariesToChoose.forEach((binary, index) => {
+      logger.log(`  ${index + 1}. ${binary}`);
+    });
+  }
+
+  const readline = require('readline');
+  const rli = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const choice = await new Promise((resolve) => {
+    rli.question(`Enter binary number to install (1-${binariesToChoose.length}), or 'all' for all: `, (ans) => {
+      rli.close();
+      resolve(ans.trim().toLowerCase());
+    });
+  });
+
+  if (choice === 'all') {
+    return binariesToChoose;
+  }
+
+  const numericChoice = parseInt(choice);
+  if (numericChoice >= 1 && numericChoice <= binariesToChoose.length) {
+    return [binariesToChoose[numericChoice - 1]];
+  }
+
+  // Default to first binary if invalid choice
+  if (logger) {
+    logger.log(`Invalid choice, installing first binary: ${binariesToChoose[0]}`);
+  }
+  return [binariesToChoose[0]];
+};
+
 // Use extractName from config for consistent name normalization
 
 /**
@@ -328,8 +444,9 @@ const processExtractedPackages = async (
         };
       } else if (dmgBinaries.length > 0) {
         logger.log("No .app or .pkg found in DMG, trying to install executables");
+        const selectedBinaries = await selectBinaries(dmgBinaries, selectedName, logger);
         const destinations = await installBinaries(
-          dmgBinaries,
+          selectedBinaries,
           mountDir,
           selectedName,
           checkPathFn,
@@ -339,7 +456,7 @@ const processExtractedPackages = async (
         return {
           method: "dmg_binaries",
           destinations,
-          binaries: dmgBinaries.map((bin) => path.basename(bin)),
+          binaries: selectedBinaries.map((bin) => path.basename(bin)),
         };
       } else {
         throw new Error("No installable files found in DMG");
@@ -517,6 +634,7 @@ module.exports = {
   selectBestAsset,
   extractArchive,
   getBinaries,
+  selectBinaries,
   processExtractedPackages,
   installApp,
   installPkg,