Upload New Files

Author: mxnt10

Cargo.lock

@@ -1,14 +1,13 @@
 [package]
 name = "Rex"
-version = "1.0.0"
+version = "1.1.0"
 edition = "2024"
 
 [dependencies]
 clap = { version = "4.0", features = ["derive"] }
 tar = "0.4"
 zstd = "0.13"
 fs_extra = "1.3"
-xz2 = "0.1"
 
 [profile.release]
 opt-level = "z"

Cargo.toml

@@ -1,5 +1,8 @@
- 
-# Rex - Static Rust Executable Generator and Runtime
+<p align="center">
+  <img src="logo.png" width="256">
+</p>
+
+<h1 align="center">Rex - Static Rust Executable Generator and Runtime</h1> 
 
 **Rex** is a small Rust project that packs a target binary together with its
 dynamic libraries, extra binaries and files into a single executable.
@@ -19,10 +22,10 @@ target program using a suitable loader (glibc or musl) when available.
 * `main.rs` — CLI entrypoint. Detects whether the executable is a runtime
 (contains a payload) or is being run as the builder. Uses `clap` for the CLI.
 * `generator.rs` — The packer/generator that creates the staging directory,
-copies binaries/libs/files, creates a tar and compresses it (zstd or xz),
+copies binaries/libs/files, creates a tar and compresses it (zstd),
 and appends the payload and metadata to the runtime executable.
 * `runtime.rs` — The runtime that scans the running executable for the metadata
-marker, extracts the payload to a temporary directory, adjusts environment
+marker extracts the payload to a temporary directory, adjusts environment
 variables and executes the embedded binary.
 
 ## Building
@@ -51,23 +54,20 @@ Run `rex` (the built binary) as a generator to create a bundle:
 # typical full command
 ./rex \
   --target-binary ./myapp \
-  --output ./myapp.Rex \
-  --compression zstd \
   --compression-level 19 \
   --extra-libs /usr/lib/x86_64-linux-gnu/libexample.so \
   --extra-bins ./helpers ./tools \
   --additional-files config.json README.md
 ```
 
-If you omit `--output`, the generator will produce `myapp.Rex`
-(target file base name + `.Rex`).
+The generator will produce `myapp.Rex` (target file base name + `.Rex`).
 
 ### Runtime flags (embedded runtime inside the produced bundle)
 
 When the generated bundle runs and contains payload, the runtime inspects
 arguments. The runtime supports:
 
-* `--rex-help` — prints a short help message (English, simplified).
+* `--rex-help` — prints a short help message.
 * `--rex-extract` — extracts the embedded bundle into the **current working directory**.
 
 If no runtime flag is given, the runtime will extract to a temporary
@@ -89,13 +89,6 @@ Inside the compressed `.tar` payload the generator creates a directory named
 The runtime expects exactly this layout and looks up the active bundle
 using the `target` name provided in the appended metadata.
 
-## Compression choices
-
-* `zstd` (id `0`) — default/recommended, fast and efficient. Supports higher levels.
-* `xz` (id `1`) — stronger compression but slower.
-
-The generator accepts the flags `--compression` and `--compression-level`.
-
 ## Loader handling and execution (Linux)
 
 * The generator attempts to copy a system loader into `libs/` (ld-linux or ld-musl)
@@ -124,7 +117,7 @@ writes to the current working directory and prints progress messages.
 cargo build --release
 
 # 2) Package your app
-./target/release/rex --target-binary ./target/release/myapp --output ./myapp.Rex --compression zstd --compression-level 19
+./target/release/rex --target-binary ./target/release/myapp --compression-level 19
 
 # 3) Run the bundle
 ./myapp.Rex
@@ -137,7 +130,6 @@ Or extract files manually to inspect contents:
 # this extracts into the current directory into 'myapp_bundle/' (or similar) depending on the target name
 ```
 
-
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

README.md

@@ -1,2 +1,7 @@
+Thu Oct 23 20:19:24 -03 2025:
+    - upload version 1.1.0
+    - refactoty code
+    - use only zstd
+    - remove parameters --compression --output for clean code
 Tue Oct 21 08:04:09 -03 2025:
-    - Upload version 1.0.0
+    - upload version 1.0.0

changelog

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+VER="$(grep -Eom1 "version = \"(([0-9]+)[.])+[0-9]+" Cargo.toml)"
+
+TAG="Continuous"
+BINARY=target/x86_64-unknown-linux-musl/release/Rex
+
+gh release delete "$TAG" --yes
+gh release create "$TAG" "$BINARY" --title "$TAG" --notes "Rex v${VER#*\"} Release - 64bit"
+
+echo "Release '$TAG' criada/atualizada com o binário enviado."

logo.png

@@ -5,23 +5,19 @@ use std::io::{self, Write};
 use std::os::unix::fs::PermissionsExt;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use xz2::write::XzEncoder;
 use zstd::stream::write::Encoder;
 
 const MAGIC_MARKER: [u8; 10] = *b"REX_BUNDLE";
 
 #[repr(C, packed)]
 struct BundleMetadata {
     payload_size: u64,
-    compression_type: u32,
     target_bin_name_len: u32,
 }
 
 #[derive(Debug)]
 pub struct BundleArgs {
     pub target_binary: PathBuf,
-    pub output: PathBuf,
-    pub compression: String,
     pub compression_level: i32,
     pub extra_libs: Vec<PathBuf>,
     pub additional_files: Vec<String>,
@@ -31,12 +27,8 @@ pub struct BundleArgs {
 fn find_system_loader() -> Option<PathBuf> {
     let possible_paths = [
         "/lib64/ld-linux-x86-64.so.2",
-        "/usr/lib64/ld-linux-x86-64.so.2",
-        "/lib/ld-linux-x86-64.so.2",
-        "/usr/lib/ld-linux-x86-64.so.2",
-        "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2",
-        "/lib/ld-musl-x86_64.so.1",
-        "/usr/lib/ld-musl-x86_64.so.1"
+        "/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2",
+        "/lib/ld-musl-x86_64.so.1"
     ];
 
     for path in possible_paths.iter() {
@@ -55,35 +47,25 @@ fn create_temp_dir(base_name: &str) -> Result<PathBuf, Box<dyn Error>> {
     Ok(path)
 }
 
-fn create_compressed_payload(path: &Path, target: &str, cmp: &str, l: i32) -> Result<PathBuf, Box<dyn Error>> {
-    println!("\n[Packaging] Starting TAR archiving and {} compression (level {})...", cmp, l);
-
+fn create_compressed_payload(path: &Path, target: &str, l: i32) -> Result<PathBuf, Box<dyn Error>> {
     let tmp_dir = std::env::temp_dir().join(format!("{}_bundle_tmp", target));
     if tmp_dir.exists() {
         fs::remove_dir_all(&tmp_dir)?;
     }
     fs::create_dir_all(&tmp_dir)?;
 
-    let payload = tmp_dir.join(format!("{}.tar.{}", target, cmp));
+    let payload = tmp_dir.join(format!("{target}.tar.zstd"));
     let file_writer = File::create(&payload)?;
 
-    let encoder: Box<dyn Write> = match cmp {
-        "zstd" => {
-            let mut enc = Encoder::new(file_writer, l)?;
-            enc.long_distance_matching(true)?;
-            Box::new(enc.auto_finish())
-        }
-        "xz" => {
-            let enc = XzEncoder::new(file_writer, l as u32);
-            Box::new(enc)
-        }
-        other => return Err(format!("Unknown compression format: {}", other).into()),
-    };
+    println!("\n[Packaging] Starting TAR archiving and ZSTD compression (level {l}) to:\n{}", payload.display());
+
+    let mut enc = Encoder::new(file_writer, l)?;
+    enc.long_distance_matching(true)?;
+    let encoder: Box<dyn Write> =Box::new(enc.auto_finish());
 
     let bundle_dir_name = format!("{}_bundle", target);
     let mut builder = tar::Builder::new(encoder);
     builder.append_dir_all(&bundle_dir_name, path)?;
-    fs::remove_dir_all(&tmp_dir)?;
 
     Ok(payload)
 }
@@ -222,35 +204,27 @@ pub fn generate_bundle(args: BundleArgs) ->  Result<(), Box<dyn Error>> {
         fs_extra::copy_items(&entry_refs, root_path, &options)?;
     }
 
-    let compressed_payload_path = create_compressed_payload(root_path, &target_name, &args.compression, args.compression_level)?;
+    let compressed_payload_path = create_compressed_payload(root_path, &target_name, args.compression_level)?;
     let payload_size = compressed_payload_path.metadata()?.len();
+    let out = format!("{}.Rex", args.target_binary.file_name().unwrap().display());
 
-    println!("\n[Output] Creating final bundle file: {}", args.output.display());
+    println!("\n[Output] Creating final bundle file: {}", out);
 
     let exec = std::env::current_exe()?;
-    fs::copy(&exec, &args.output)?;
+    fs::copy(&exec, &out)?;
 
-    #[cfg(unix)]
-    {
-        use std::fs::Permissions;
-        let perms = Permissions::from_mode(0o755);
-        fs::set_permissions(&args.output, perms)?;
-    }
+    use std::fs::Permissions;
+
+    let perms = Permissions::from_mode(0o755);
+    fs::set_permissions(&out, perms)?;
 
-    let mut final_file = fs::OpenOptions::new().append(true).open(&args.output)?;
+    let mut final_file = fs::OpenOptions::new().append(true).open(&out)?;
     let mut payload_file = File::open(&compressed_payload_path)?;
 
     io::copy(&mut payload_file, &mut final_file)?;
 
-    let compression_id = match args.compression.to_lowercase().as_str() {
-        "zstd" => 0,
-        "xz" => 1,
-        _ => 99,
-    };
-
     let metadata = BundleMetadata {
         payload_size,
-        compression_type: compression_id,
         target_bin_name_len: target_name.len() as u32,
     };
 
@@ -269,6 +243,6 @@ pub fn generate_bundle(args: BundleArgs) ->  Result<(), Box<dyn Error>> {
     println!("\n[Generator Success]");
     println!("  Payload Size: {} bytes", payload_size);
     println!("  Metadata Size: {} bytes", size_of::<BundleMetadata>() + target_name.len() + MAGIC_MARKER.len());
-    println!("  Compressed Bundle created at: {}", args.output.display());
+    println!("  Compressed Bundle created at: {}", out);
     Ok(())
 }

release_git

@@ -18,16 +18,8 @@ struct Cli {
         help = "Path to the main target binary to bundle")]
     target_binary: Option<PathBuf>,
 
-    #[arg(short = 'o', long, value_name = "OUTPUT_PATH",
-        help = "Path for the generated Rex bundle")]
-    output: Option<PathBuf>,
-
-    #[arg(short = 'c', long, value_name = "COMPRESSION_TYPE", default_value = "zstd",
-        help = "Compression type to use for the payload (zstd or xz)")]
-    compression: String,
-
     #[arg(short = 'L', long, value_name = "COMPRESSION_LEVEL", default_value_t = 5,
-        help = "Compression level (1-22 for zstd, 0-9 for xz)")]
+        help = "Compression level (1-22)")]
     compression_level: i32,
 
     #[arg(short = 'l', long, value_name = "EXTRA_LIBRARIES",
@@ -51,27 +43,14 @@ fn rex_main(runtime: &mut Runtime) -> Result<(), Box<dyn Error>> {
         return runtime.run()
     }
 
-    let has_no_args = args_vec.len() == 1;
-    if has_no_args && !is_runtime {
-        let mut cmd = Cli::command();
-        cmd.print_help()?;
-        return Ok(())
+    if args_vec.len() == 1 {
+        Cli::command().print_help()?;
+        return Ok(());
     }
 
     let cli = Cli::parse();
-    let target = cli.target_binary.unwrap();
-    let final_output = match cli.output {
-        Some(p) => p,
-        None => {
-            let file_name = target.file_name().unwrap().to_str().unwrap();
-            PathBuf::from(format!("{}.Rex", file_name))
-        }
-    };
-
     let args = generator::BundleArgs {
-        target_binary: target,
-        output: final_output,
-        compression: cli.compression,
+        target_binary: cli.target_binary.unwrap(),
         compression_level: cli.compression_level,
         extra_libs: cli.extra_libs,
         extra_bins: cli.extra_bins,