feat: add way to access and shim internal binaries

Author: helton

README.md

@@ -16,6 +16,7 @@ hbox offers the following features:
 - **Robust Configuration Options**: hbox enables high customization through configuration files. You can define package aliases and setup automatic volume mounts via `config.json`.
 - **Support for Pipes**: hbox supports the use of pipes in `hbox run`, which allows you to chain commands efficiently.
 - **Convenient Shims**: hbox creates `shims` (alias shortcuts) for all installed packages, simplifying command entry from `hbox run <package alias> <commands>` to `<package alias> <commands>`.
+- **Accessible Internal Binaries**: hbox has the ability to provide direct access to internal binaries within images. Users can override the default entrypoint, meaning essential tools and utilities within containers can be accessed directly. This feature further expands the capabilities of hbox `shims`, making it even more convenient to launch and utilize container tools.
 
 ## Commands
 
@@ -68,6 +69,44 @@ In the future this will be centralized in on its own repo/server, so you can fet
 ```json
 {
   "packages": {
+    "busybox": {
+      "image": "docker.io/busybox",
+      "volumes": [
+        {
+          "source": ".",
+          "target": "/app"
+        }
+      ],
+      "current_directory": "/app",
+      "binaries": [
+        {
+          "name": "tree",
+          "path": "/bin/tree"
+        }
+      ],
+      "only_shim_binaries": true
+    },
+    "golang": {
+      "image": "docker.io/golang",
+      "volumes": [
+        {
+          "source": ".",
+          "target": "/app"
+        }
+      ],
+      "current_directory": "/app",
+      "binaries": [
+        {
+          "name": "go",
+          "path": "/usr/local/go/bin/go"
+        },
+        {
+          "name": "gofmt",
+          "path": "/usr/local/go/bin/gofmt"
+        }
+      ],
+      "only_shim_binaries": true
+    },
     "curl": {
       "image": "docker.io/curlimages/curl"
     },

src/commands.rs

@@ -85,7 +85,7 @@ pub fn remove_package(name: String, version: Option<String>) -> Result<(), Box<d
                 if package.versions.versions.contains(&version) {
                     package.versions.versions.retain(|v| v != version.as_str());
                     if package.versions.versions.is_empty() {
-                        do_remove_package(&name)?;
+                        do_remove_package(package)?;
                         println!("Removed package '{}'.", name);
                     } else {
                         upsert(&name, package)?;
@@ -97,8 +97,8 @@ pub fn remove_package(name: String, version: Option<String>) -> Result<(), Box<d
                 }
             }
         }
-        (Some(_), None) => {
-            do_remove_package(&name)?;
+        (Some(package), None) => {
+            do_remove_package(package)?;
             println!("Removed package '{}'.", name);
             Ok(())
         }
@@ -126,8 +126,15 @@ pub fn set_package_version(name: String, version: String) -> Result<(), Box<dyn
 }
 
 pub fn run_package(name: String, subcommand: Vec<String>) -> Result<(), Box<dyn Error>> {
-    if let Some(package) = Package::load(&name)? {
-        run(&package, &subcommand);
+    let parts: Vec<&str> = name.split("::").collect();
+    let (package_name, binary) = match parts.as_slice() {
+        [package_name] => (package_name.to_string(), None),
+        [package_name, binary] => (package_name.to_string(), Some(binary.to_string())),
+        _ => return Err(format!("Invalid package name '{}'.", name).into()),
+    };
+
+    if let Some(package) = Package::load(&package_name)? {
+        run(&package, binary, &subcommand);
         Ok(())
     } else {
         Err(format!("Package '{}' does not exists.", name).into())
@@ -138,16 +145,30 @@ fn do_add_package(name: &String, version: &String, package: Package) -> Result<(
     let mut new_package = package.clone();
     new_package.versions.current = version.clone();
     if crate::runner::pull(&new_package) {
+        if !&package.index.only_shim_binaries {
+            add_shim(&name, None)?;
+        }
+        if let Some(binaries) = &package.index.binaries {
+            for binary in binaries {
+                add_shim(&name, Some(&binary.name))?;
+            }
+        }
         upsert(&name, package)?;
-        add_shim(&name)?;
         Ok(())
     } else {
         Err(format!("Failed to add package '{}' at version '{}'.", name, version).into())
     }
 }
 
-fn do_remove_package(name: &String) -> Result<(), Box<dyn Error>> {
-    remove(&name)?;
-    remove_shim(&name)?;
+fn do_remove_package(package: Package) -> Result<(), Box<dyn Error>> {
+    remove(&package.name)?;
+    if !&package.index.only_shim_binaries {
+        remove_shim(&package.name)?;
+    }
+    if let Some(binaries) = &package.index.binaries {
+        for binary in binaries {
+            remove_shim(&binary.name)?;
+        }
+    }
     Ok(())
 }

src/files/index.rs

@@ -14,14 +14,19 @@ pub struct Package {
     pub image: String,
     pub volumes: Option<Vec<Volume>>,
     pub current_directory: Option<String>,
+    pub binaries: Option<Vec<Binary>>,
+    #[serde(default)]
+    pub only_shim_binaries: bool,
 }
 
 impl Package {
     pub fn new(name: &str) -> Self {
         Package {
             image: format!("docker.io/{}", name),
             volumes: None,
-            current_directory: None
+            current_directory: None,
+            binaries: None,
+            only_shim_binaries: false
         }
     }
 }
@@ -32,6 +37,12 @@ pub struct Volume {
     pub target: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Binary {
+    pub name: String,
+    pub path: String,
+}
+
 pub fn parse() -> Result<Root, Box<dyn Error>> {
     let config = AppConfig::new();
     parse_json(&config.index_path())

src/packages.rs

@@ -57,6 +57,13 @@ impl Package {
                 println!("    - {}:{}", volume.source, volume.target);
             }
         }
+        if let Some(binaries) = &self.index.binaries {
+            println!("  - binaries:");
+            for binary in binaries {
+                println!("    - {} -> {}", binary.name, binary.path);
+            }
+        }
+        println!("  - only_shim_binaries: {}", &self.index.only_shim_binaries);
         if let Some(current_directory) = &self.index.current_directory {
             println!("  - current directory: {}", current_directory.clone());
         }

src/runner.rs

@@ -37,7 +37,7 @@ fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
     }
 }
 
-pub fn run(package: &Package, params: &Vec<String>) -> bool {
+pub fn run(package: &Package, binary: Option<String>, params: &Vec<String>) -> bool {
     let interactive = !atty::is(Stream::Stdin);
 
     let mut buffer = Vec::new();
@@ -69,6 +69,17 @@ pub fn run(package: &Package, params: &Vec<String>) -> bool {
         args.push(current_directory.clone());
     }
 
+    if let Some(b) = binary {
+        if let Some(binaries) = &package.index.binaries {
+            for binary in binaries {
+                if binary.name == b {
+                    args.push("--entrypoint".to_string());
+                    args.push(binary.path.to_string());
+                }
+            }
+        }
+    }
+
     args.push(format!(
         "{}:{}",
         package.index.image.clone(),

src/shims.rs

@@ -3,20 +3,26 @@ use std::fs::{self, File};
 use std::io::Write;
 use std::path::PathBuf;
 
-pub fn add_shim(name: &str) -> std::io::Result<()> {
+pub fn add_shim(name: &str, binary: Option<&str>) -> std::io::Result<()> {
     let config = AppConfig::new();
-    let shims_file_path = get_shims_path(name, config);
+    let shim_name = binary.unwrap_or_else(|| name);
+    let shims_file_path = get_shims_path(shim_name, config);
 
     if !shims_file_path.exists() {
         fs::create_dir_all(shims_file_path.parent().unwrap())?;
         let mut shim_file = File::create(&shims_file_path)?;
 
+        let command = match binary {
+            Some(bin) => format!("{}::{}", name, bin),
+            None => name.to_string()
+        };
+
         if std::env::consts::OS == "windows" {
             shim_file.write_all(b"@echo off\n")?;
-            shim_file.write_all(format!("hbox.exe run {} %*\n", name).as_bytes())?;
+            shim_file.write_all(format!("hbox.exe run {} %*\n", command).as_bytes())?;
         } else {
             shim_file.write_all(b"#!/bin/sh\n")?;
-            shim_file.write_all(format!("hbox run {} \"$@\"\n", name).as_bytes())?;
+            shim_file.write_all(format!("hbox run {} \"$@\"\n", command).as_bytes())?;
         }
 
         if std::env::consts::OS != "windows" {