feat: Zig 0.16.0 compatibility — cross-compile, CLI args, process spawn

## Cross-compilation fixes (Zig 0.16.0 API changes)

- Replace std.c.stat with Io.Dir.cwd().statFile — std.c removed from
  cross-compilation C headers in Zig 0.16.0
- Rename Permissions.unixNew → Permissions.fromMode — API renamed
- Remove unused arena parameter from maybe_install_musl_runtime
  (arena.dupeZ replaced by statFile which takes a string directly)
- Comptime-guard the musl runtime call site to avoid unused-parameter
  warnings on macOS (the function only runs on Linux)

## Process spawning (cross-platform)

- Replace std.process.replace with std.process.spawn + child.wait
  std.process.replace does not work reliably on macOS arm64 in Zig 0.16.0
- Unify Windows/Unix code paths — both use the same spawn+wait pattern
  (removes the broken Windows-only std.process.Child.spawnAndWait)
- Use .exited (lowercase) for Child.Term enum, var for mutable Child

## CLI argument passing

- Pass CLI args via ADO_ARGS environment variable in the Zig wrapper
  (the -extra BEAM flag does not reliably reach init:get_plain_arguments()
  in certain release configurations)
- Join args_trimmed into a space-separated string and set as ADO_ARGS

All targets compile: macOS (arm64/x86_64), Linux (x86_64/arm64), Windows (x86_64)

Author: gilbertwong96

src/erlang_launcher.zig

@@ -47,6 +47,23 @@ pub fn launch(io: Io, install_dir: []const u8, env_map: *std.process.Environ.Map
     }
 
     // Set all the required release arguments
+
+    // Pass CLI args via ADO_ARGS env var (reliable, works around -extra quirks)
+    var args_buf: [4096]u8 = undefined;
+    var args_len: usize = 0;
+    for (args_trimmed, 0..) |arg, i| {
+        if (i > 0) {
+            args_buf[args_len] = ' ';
+            args_len += 1;
+        }
+        const end = args_len + arg.len;
+        if (end < args_buf.len) {
+            @memcpy(args_buf[args_len..end], arg);
+            args_len = end;
+        }
+    }
+    try env_map.put("ADO_ARGS", args_buf[0..args_len]);
+
     const erlang_cli = &[_][]const u8{
         erl_bin_path[0..],
         "-elixir ansi_enabled true",
@@ -67,54 +84,37 @@ pub fn launch(io: Io, install_dir: []const u8, env_map: *std.process.Environ.Map
         "-extra",
     };
 
-    if (builtin.os.tag == .windows) {
-        // Fix up Windows 10+ consoles having ANSI escape support, but only if we set some flags
-        const final_args = try std.mem.concat(allocator, []const u8, &.{ erlang_cli, args_trimmed });
-
-        try env_map.put("RELEASE_ROOT", install_dir);
-        try env_map.put("RELEASE_SYS_CONFIG", config_sys_path_no_ext);
-        try env_map.put("__BURRITO", "1");
-        try env_map.put("__BURRITO_BIN_PATH", self_path);
-
-        var win_child_proc = std.process.Child.init(final_args, allocator);
-        win_child_proc.env_map = env_map;
-        win_child_proc.stdout_behavior = .Inherit;
-        win_child_proc.stdin_behavior = .Inherit;
-
-        log.debug("CLI List: {any}", .{final_args});
-
-        const win_term = try win_child_proc.spawnAndWait();
-        switch (win_term) {
-            .Exited => |code| {
-                std.process.exit(code);
-            },
-            else => std.process.exit(1),
-        }
-    } else {
-        const final_args = try std.mem.concat(allocator, []const u8, &.{ erlang_cli, args_trimmed });
+    // Cross-platform: build args once, set env, spawn child, wait for exit
+    const final_args = try std.mem.concat(allocator, []const u8, &.{ erlang_cli, args_trimmed });
 
-        log.debug("CLI List: {any}", .{final_args});
+    log.debug("CLI List: {any}", .{final_args});
 
+    try env_map.put("RELEASE_ROOT", install_dir);
+    try env_map.put("RELEASE_SYS_CONFIG", config_sys_path_no_ext);
+    try env_map.put("__BURRITO", "1");
+    try env_map.put("__BURRITO_BIN_PATH", self_path);
+
+    // Unix: set ROOTDIR, BINDIR, LD_LIBRARY_PATH for NIF .so files
+    if (builtin.os.tag != .windows) {
         try env_map.put("ROOTDIR", install_dir[0..]);
         try env_map.put("BINDIR", erts_bin_path[0..]);
-        try env_map.put("RELEASE_ROOT", install_dir);
-        try env_map.put("RELEASE_SYS_CONFIG", config_sys_path_no_ext);
-        try env_map.put("__BURRITO", "1");
-        try env_map.put("__BURRITO_BIN_PATH", self_path);
 
-        // Extend LD_LIBRARY_PATH so NIF .so files can find system shared
-        // libraries (e.g. libgcc_s.so.1) when using a custom glibc ERTS
         const system_lib_paths = "/lib/x86_64-linux-gnu:/usr/lib/x86_64-linux-gnu:/lib:/usr/lib";
         if (env_map.get("LD_LIBRARY_PATH")) |existing| {
             const combined = try std.fmt.allocPrint(allocator, "{s}:{s}", .{ existing, system_lib_paths });
             try env_map.put("LD_LIBRARY_PATH", combined);
         } else {
             try env_map.put("LD_LIBRARY_PATH", system_lib_paths);
         }
+    }
 
-        return std.process.replace(io, .{
-            .argv = final_args,
-            .environ_map = env_map,
-        });
+    var child = try std.process.spawn(io, .{
+        .argv = final_args,
+        .environ_map = env_map,
+    });
+    const term = try child.wait(io);
+    switch (term) {
+        .exited => |code| std.process.exit(code),
+        else => std.process.exit(1),
     }
 }

src/wrapper.zig

@@ -46,7 +46,7 @@ pub fn main(init: std.process.Init) !void {
     const environ = init.minimal.environ;
 
     // If on linux, maybe install the musl libc runtime file for our pre-compiled Erlang
-    try maybe_install_musl_runtime(io, arena);
+    if (comptime IS_LINUX) try maybe_install_musl_runtime(io);
 
     const self_path = try std.process.executablePathAlloc(io, arena);
 
@@ -218,16 +218,14 @@ fn install_dir_error(arena: std.mem.Allocator) void {
     std.process.exit(1);
 }
 
-fn maybe_install_musl_runtime(io: Io, arena: std.mem.Allocator) !void {
-    if (comptime IS_LINUX and !std.mem.eql(u8, build_options.MUSL_RUNTIME_PATH, "")) {
-        // Check if the file was already extracted
-        const cStr = try arena.dupeZ(u8, build_options.MUSL_RUNTIME_PATH);
-        var statBuffer: std.c.Stat = undefined;
-        const statResult = std.c.stat(cStr, &statBuffer);
+fn maybe_install_musl_runtime(io: Io) !void {
+    if (!std.mem.eql(u8, build_options.MUSL_RUNTIME_PATH, "")) {
+        // Check if the file was already extracted using std.fs API (cross-platform)
+        const file_exists = Io.Dir.cwd().statFile(io, build_options.MUSL_RUNTIME_PATH, .{}) catch null;
 
-        if (statResult == 0) {
+        if (file_exists != null) {
             // File exists
-            log.debug("The musl runtime file is already preset. Continuing.", .{});
+            log.debug("The musl runtime file is already present. Continuing.", .{});
             return;
         }
 
@@ -237,7 +235,7 @@ fn maybe_install_musl_runtime(io: Io, arena: std.mem.Allocator) !void {
         };
         defer file.close(io);
 
-        const exec_permissions = Io.File.Permissions.unixNew(0o754);
+        const exec_permissions = Io.File.Permissions.fromMode(@intCast(0o754));
         try file.setPermissions(io, exec_permissions);
 
         const MUSL_RUNTIME_BYTES = @embedFile("musl-runtime.so");