feat: add run command

Author: helton

Cargo.lock

@@ -11,3 +11,4 @@ clap = { version = "4.5.4", features = ["derive"] }
 colored = "2.1.0"
 serde = { version = "1.0.201", features = ["derive"] }
 serde_json = "1.0.117"
+atty = "0.2.14"

Cargo.toml

@@ -61,7 +61,7 @@ enum Commands {
         name: String,
 
         /// Arguments to pass to the package
-        #[arg(required = true, last = true)]
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         subcommand: Vec<String>,
     },
 }

src/cli.rs

@@ -5,6 +5,7 @@ use std::env;
 use std::error::Error;
 use crate::files::versions::{remove, upsert};
 use crate::packages::Package;
+use crate::runner::run;
 
 pub fn show_info() -> Result<(), Box<dyn Error>> {
     println!("\n{}:", "System Information".bold().underline());
@@ -58,7 +59,7 @@ pub fn add_package(name: String, version: String, set_default: bool) -> Result<(
         }
         run_pull_and_add_shim(&name, &version, package)?;
     } else {
-        let package = Package::new(&name, crate::files::index::Package::new(&name), crate::files::versions::Package::new(&version));
+        let package = Package::new(&name, crate::files::versions::Package::new(&version))?;
         run_pull_and_add_shim(&name, &version, package)?;
     }
     Ok(())
@@ -110,13 +111,20 @@ 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>> {
-    Ok(())
+pub fn run_package(name: String, subcommand: Vec<String>) -> Result<(), Box<dyn Error>> {
+    if let Some(package) = Package::load(&name)? {
+        run(&package, &subcommand);
+        Ok(())
+    } else {
+        Err(format!("Package '{}' does not exists.", name).into())
+    }
 }
 
 fn run_pull_and_add_shim(name: &String, version: &String, package: Package) -> Result<(), Box<dyn Error>> {
-    if crate::runner::pull(&package) {
-        crate::files::versions::upsert(&name, package)?;
+    let mut new_package = package.clone();
+    new_package.versions.current = version.clone();
+    if crate::runner::pull(&new_package) {
+        upsert(&name, package)?;
         add_shim(&name)?;
         Ok(())
     } else {

src/commands.rs

@@ -2,7 +2,7 @@ use crate::files::index::Package as IndexPackage;
 use crate::files::versions::Package as VersionsPackage;
 use std::error::Error;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Package {
     pub name: String,
     pub index: IndexPackage,
@@ -11,12 +11,16 @@ pub struct Package {
 
 // Public API
 impl Package {
-    pub fn new(name: &str, index_package: IndexPackage, versions_package: VersionsPackage) -> Self {
-        Self {
+    pub fn new(name: &str, versions_package: VersionsPackage) -> Result<Self, Box<dyn Error>> {
+        let index_packages = crate::files::index::parse()?;
+        let index_package = index_packages.packages.get(name)
+            .map(|pkg| pkg.to_owned())
+            .unwrap_or_else(|| IndexPackage::new(name));
+        Ok(Self {
             name: String::from(name),
             index: index_package,
             versions: versions_package,
-        }
+        })
     }
 
     pub fn load(name: &str) -> Result<Option<Self>, Box<dyn Error>> {

src/packages.rs

@@ -1,16 +1,56 @@
+use std::io::{self, Read, Write};
+use std::process::{Command, Stdio};
+use atty::Stream;
 use crate::packages::Package;
 
-pub fn pull(package: &Package) -> bool {
-    let command = format!("docker pull {}", package.container_image_url());
-    run_command(&command)
+fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
+    println!("Running command: {}", command);
+
+    let mut parts = command.split_whitespace();
+    let cmd = parts.next().unwrap();  // Extract command
+    let args = parts.collect::<Vec<_>>();  // Extract arguments
+
+    let mut child = Command::new(cmd)
+        .args(args)
+        .stdout(Stdio::inherit())  // Inherit stdout
+        .stderr(Stdio::inherit())  // Inherit stderr
+        .stdin(Stdio::piped())  // Set stdin to piped to write the buffer later
+        .spawn()  // Spawn the command
+        .expect("Failed to spawn command");
+
+    // If stdin_buffer is Some, write it to the child's stdin
+    if let Some(buffer) = stdin_buffer {
+        let child_stdin = child.stdin.as_mut().expect("Failed to open stdin");
+        child_stdin.write_all(&buffer).expect("Failed to write to stdin");
+    }
+
+    // Wait for the command to complete and check the status
+    match child.wait() {
+        Ok(status) => status.success(),
+        Err(e) => {
+            println!("Command failed to complete: {}", e);
+            false
+        }
+    }
 }
 
 pub fn run(package: &Package, params: &Vec<String>) -> bool {
-    let command = format!("docker run {} {}", package.name, params.join(" "));
-    run_command(&command)
+    let interactive = !atty::is(Stream::Stdin);
+
+    let mut buffer = Vec::new();
+    if interactive {
+        io::stdin().read_to_end(&mut buffer).expect("Failed to read stdin");
+        buffer.len();
+    }
+
+    let interactive_flag = if interactive { "-i " } else { "" };
+    let command = format!("docker run {}{} {}", interactive_flag, package.container_image_url(), params.join(" "));
+
+    run_command(&command, Some(buffer))
 }
 
-fn run_command(command: &str) -> bool {
-    println!("Pretending I'm running {}", command);
-    true
+pub fn pull(package: &Package) -> bool {
+    let command = format!("docker pull {}", package.container_image_url());
+    // Normally, pull does not need stdin interaction
+    run_command(&command, None)
 }