fix(pkg): pass explicit -z/-j flags for non-auto-detecting tar

OpenBSD tar doesn't auto-detect compression format and requires
explicit -z (gzip) or -j (bzip2) flags.

This adds tar implementation detection via --version output:
- 'bsdtar' or 'libarchive' -> BSD tar (auto-detects compression)
- 'GNU tar' -> GNU tar (auto-detects compression)
- Otherwise -> Other (needs explicit flags)

Fixes #10123

Signed-off-by: Ali Caglayan <alizter@gmail.com>

Author: Alizter

src/dune_pkg/archive_driver.ml

@@ -2,6 +2,15 @@ open Stdune
 module Process = Dune_engine.Process
 open Fiber.O
 
+(** Tar implementation type, detected via --version output:
+    - Libarchive: libarchive/bsdtar - auto-detects compression, can extract zip
+    - Gnu: GNU tar - auto-detects compression, no zip support
+    - Other: Unknown (e.g. OpenBSD) - needs explicit -z/-j flags *)
+type tar_impl =
+  | Libarchive
+  | Gnu
+  | Other
+
 module Command = struct
   type t =
     { bin : Path.t
@@ -16,8 +25,45 @@ type t =
 
 let which bin_name = Bin.which ~path:(Env_path.path Env.initial) bin_name
 
-let make_tar_args ~archive ~target_in_temp =
-  [ "xf"; Path.to_string archive; "-C"; Path.to_string target_in_temp ]
+(* Regexes for detecting tar implementation from --version output *)
+let libarchive_re = Re.compile (Re.alt [ Re.str "bsdtar"; Re.str "libarchive" ])
+let gnu_tar_re = Re.compile (Re.str "GNU tar")
+
+(** Detect tar implementation by running --version *)
+let detect_tar_impl bin =
+  let+ output, _ = Process.run_capture ~display:Quiet Return bin [ "--version" ] in
+  if Re.execp libarchive_re output
+  then Libarchive
+  else if Re.execp gnu_tar_re output
+  then Gnu
+  else Other
+;;
+
+(** Generate tar arguments, adding -z/-j for non-auto-detecting tar *)
+let make_tar_args ~tar_impl ~archive ~target_in_temp =
+  let decompress_flag =
+    match tar_impl with
+    | Libarchive | Gnu -> [] (* auto-detect compression *)
+    | Other ->
+      (* Need explicit flags for tar implementations that don't auto-detect *)
+      let archive_str = Path.to_string archive in
+      if
+        Filename.check_suffix archive_str ".tar.gz"
+        || Filename.check_suffix archive_str ".tgz"
+      then [ "-z" ]
+      else if
+        Filename.check_suffix archive_str ".tar.bz2"
+        || Filename.check_suffix archive_str ".tbz"
+      then [ "-j" ]
+      else
+        (* CR-soon alizter: handle .tar.xz (-J) and .tar.lzma (--lzma) which
+           OPAM also supports. Should error with a clear message if the tar
+           implementation doesn't support auto-detection for these formats. *)
+        []
+  in
+  [ "-x" ]
+  @ decompress_flag
+  @ [ "-f"; Path.to_string archive; "-C"; Path.to_string target_in_temp ]
 ;;
 
 let make_zip_args ~archive ~target_in_temp =
@@ -27,12 +73,10 @@ let make_zip_args ~archive ~target_in_temp =
 let tar =
   let command =
     Fiber.Lazy.create (fun () ->
-      match
-        (* Test for tar before bsdtar as tar is more likely to be installed
-            and both work equally well for tarballs. *)
-        List.find_map [ "tar"; "bsdtar" ] ~f:which
-      with
-      | Some bin -> Fiber.return { Command.bin; make_args = make_tar_args }
+      match List.find_map [ "tar"; "bsdtar" ] ~f:which with
+      | Some bin ->
+        let+ tar_impl = detect_tar_impl bin in
+        { Command.bin; make_args = make_tar_args ~tar_impl }
       | None ->
         Fiber.return
         @@ User_error.raise
@@ -43,13 +87,16 @@ let tar =
   { command; suffixes = [ ".tar"; ".tar.gz"; ".tgz"; ".tar.bz2"; ".tbz" ] }
 ;;
 
-let which_bsdtar (bin_name : string) =
-  match which bin_name with
-  | None -> Fiber.return None
-  | Some bin ->
-    let+ output, _error = Process.run_capture ~display:Quiet Return bin [ "--version" ] in
-    let re = Re.compile (Re.str "bsdtar") in
-    if Re.execp re output then Some bin else None
+let rec find_libarchive_tar = function
+  | [] -> Fiber.return None
+  | name :: rest ->
+    (match which name with
+     | None -> find_libarchive_tar rest
+     | Some bin ->
+       detect_tar_impl bin
+       >>= (function
+        | Libarchive -> Fiber.return (Some bin)
+        | Gnu | Other -> find_libarchive_tar rest))
 ;;
 
 let zip =
@@ -58,18 +105,11 @@ let zip =
       match which "unzip" with
       | Some bin -> Fiber.return { Command.bin; make_args = make_zip_args }
       | None ->
-        let rec find_tar programs =
-          match programs with
-          | [] -> Fiber.return None
-          | x :: xs ->
-            let* res = which_bsdtar x in
-            (match res with
-             | Some _ -> Fiber.return res
-             | None -> find_tar xs)
-        in
-        let* program = find_tar [ "bsdtar"; "tar" ] in
+        (* Only libarchive can extract zip, so find a tar that is libarchive *)
+        let* program = find_libarchive_tar [ "bsdtar"; "tar" ] in
         (match program with
-         | Some bin -> Fiber.return { Command.bin; make_args = make_tar_args }
+         | Some bin ->
+           Fiber.return { Command.bin; make_args = make_tar_args ~tar_impl:Libarchive }
          | None ->
            Fiber.return
            @@ User_error.raise

test/blackbox-tests/test-cases/pkg/openbsd-tar.t

@@ -1,4 +1,4 @@
-Test that demonstrates the issue with OpenBSD-style tar (#10123).
+Test that OpenBSD-style tar works when dune passes explicit flags (#10123).
 
 Unlike GNU tar and BSD tar (libarchive), OpenBSD tar requires explicit
 flags for compressed archives: -z for gzip, -j for bzip2, etc.
@@ -17,17 +17,17 @@ Set up a fake tar that behaves like OpenBSD tar:
   >     echo "tar (OpenBSD)"
   >     ;;
   >   *)
-  >     # Dune passes: xf archive -C target (or xzf archive -C target with fix)
-  >     flags="$1"
-  >     archive="$2"
-  >     target="$4"
+  >     # Dune passes: -x -z -f archive -C target (or -x -j -f ... for bzip2)
+  >     # $4 = archive, $6 = target
+  >     archive="$4"
+  >     target="$6"
   >     # Require correct flag for compressed archives
   >     case "$archive" in
   >       *.tar.gz|*.tgz)
-  >         echo "$flags" | grep -q 'z' || { echo "tar: Cannot open: compressed archive requires -z flag" >&2; exit 1; }
+  >         echo "$@" | grep -q '\-z' || { echo "tar: Cannot open: compressed archive requires -z flag" >&2; exit 1; }
   >         ;;
   >       *.tar.bz2|*.tbz)
-  >         echo "$flags" | grep -q 'j' || { echo "tar: Cannot open: compressed archive requires -j flag" >&2; exit 1; }
+  >         echo "$@" | grep -q '\-j' || { echo "tar: Cannot open: compressed archive requires -j flag" >&2; exit 1; }
   >         ;;
   >     esac
   >     # Success - create fake extracted content
@@ -48,7 +48,7 @@ Set up fake PATH with only our OpenBSD-style tar:
   $ ln -s $(which grep) .fakebin/grep
   $ ln -s ../.binaries/openbsd-tar .fakebin/tar
 
-Test with a .tar.gz file - fails because dune doesn't pass -z flag:
+Test with a .tar.gz file:
 
   $ echo "fake tarball" > test.tar.gz
 
@@ -59,13 +59,15 @@ Test with a .tar.gz file - fails because dune doesn't pass -z flag:
   > (version dev)
   > EOF
 
-  $ PATH=.fakebin build_pkg foo 2>&1 | grep -A2 '^Error'
-  Error: failed to extract 'test.tar.gz'
-  Reason: 'tar' failed with non-zero exit code '1' and output:
-  - tar: Cannot open: compressed archive requires -z flag
-  [1]
+  $ PATH=.fakebin build_pkg foo
 
-Test with a .tbz file - fails because dune doesn't pass -j flag:
+Verify that -z flag was passed:
+
+  $ dune trace cat | jq -c 'include "dune"; processes | select(.args.prog | contains("tar")) | .args.process_args | map(if (startswith("/") or startswith("_build")) then "PATH" else . end)'
+  ["--version"]
+  ["-x","-z","-f","PATH","-C","PATH"]
+
+Test with a .tbz file (bzip2 compressed):
 
   $ echo "fake tarball" > test.tbz
 
@@ -76,8 +78,10 @@ Test with a .tbz file - fails because dune doesn't pass -j flag:
   > (version dev)
   > EOF
 
-  $ PATH=.fakebin build_pkg bar 2>&1 | grep -A2 '^Error'
-  Error: failed to extract 'test.tbz'
-  Reason: 'tar' failed with non-zero exit code '1' and output:
-  - tar: Cannot open: compressed archive requires -j flag
-  [1]
+  $ PATH=.fakebin build_pkg bar
+
+Verify that -j flag was passed:
+
+  $ dune trace cat | jq -c 'include "dune"; processes | select(.args.prog | contains("tar")) | .args.process_args | map(if (startswith("/") or startswith("_build")) then "PATH" else . end)'
+  ["--version"]
+  ["-x","-j","-f","PATH","-C","PATH"]

test/blackbox-tests/test-cases/pkg/zip-extract-fail.t

@@ -10,10 +10,19 @@ expected location:
   > #!/usr/bin/env sh
   > case "$1" in
   >  --version)
-  >    echo "tar"
+  >    echo "GNU tar"
   >  ;;
   >  *)
-  >    cp "$2" "$4/$(basename "${2%.zip}")"
+  >    # Parse: -x -f archive -C target
+  >    archive=""; target=""
+  >    while [ $# -gt 0 ]; do
+  >      case "$1" in
+  >        -f) archive="$2"; shift 2 ;;
+  >        -C) target="$2"; shift 2 ;;
+  >        *) shift ;;
+  >      esac
+  >    done
+  >    cp "$archive" "$target/$(basename "${archive%.zip}")"
   > esac
   > EOF
   $ chmod +x .binaries/gnutar
@@ -24,13 +33,23 @@ expected location:
   >    echo "bsdtar"
   >  ;;
   >  *)
-  >    cp "$2" "$4/$(basename "${2%.zip}")"
+  >    # Parse: -x -f archive -C target
+  >    archive=""; target=""
+  >    while [ $# -gt 0 ]; do
+  >      case "$1" in
+  >        -f) archive="$2"; shift 2 ;;
+  >        -C) target="$2"; shift 2 ;;
+  >        *) shift ;;
+  >      esac
+  >    done
+  >    cp "$archive" "$target/$(basename "${archive%.zip}")"
   > esac
   > EOF
   $ chmod +x .binaries/bsdtar
   $ cat > .binaries/unzip << 'EOF'
   > #!/usr/bin/env sh
-  > cp "$2" "$4/$(basename "${2%.zip}")"
+  > # unzip archive -d target
+  > cp "$1" "$3/$(basename "${1%.zip}")"
   > EOF
   $ chmod +x .binaries/unzip
 
@@ -40,6 +59,7 @@ Set up a folder that we will inject as fake PATH:
   $ ln -s $(which dune) .fakebin/dune
   $ ln -s $(which sh) .fakebin/sh
   $ ln -s $(which cp) .fakebin/cp
+  $ ln -s $(which basename) .fakebin/basename
   $ show_path() {
   >   ls .fakebin | sort | xargs
   > }
@@ -66,7 +86,7 @@ Build the package in an environment without unzip, or tar, or bsdtar.
 variable can escape to subseqent shell invocations on MacOS.)
 
   $ show_path
-  cp dune sh
+  basename cp dune sh
   $ (PATH=.fakebin build_pkg foo 2>&1 | grep '^Error:' -A 3)
   Error: No program found to extract zip file. Tried:
   - unzip
@@ -78,7 +98,7 @@ Build with only GNU tar that can't extract ZIP archives:
 
   $ ln -s ../.binaries/gnutar .fakebin/tar
   $ show_path
-  cp dune sh tar
+  basename cp dune sh tar
   $ (PATH=.fakebin build_pkg foo 2>&1 | grep '^Error:' -A 3)
   Error: No program found to extract zip file. Tried:
   - unzip
@@ -91,7 +111,7 @@ Build with bsdtar that can extract ZIP archives, without unzip. It should work:
   $ rm .fakebin/tar
   $ ln -s ../.binaries/bsdtar .fakebin/tar
   $ show_path
-  cp dune sh tar
+  basename cp dune sh tar
   $ (PATH=.fakebin build_pkg foo)
 
 Build the package with bsdtar and tar. Now our fake bsdtar will get picked up
@@ -101,13 +121,13 @@ and used to extract:
   $ ln -s ../.binaries/gnutar .fakebin/tar
   $ ln -s ../.binaries/bsdtar .fakebin/bsdtar
   $ show_path
-  bsdtar cp dune sh tar
+  basename bsdtar cp dune sh tar
   $ (PATH=.fakebin build_pkg foo)
 
 Build with unzip only:
 
   $ ln -s ../.binaries/unzip .fakebin/unzip
   $ rm .fakebin/bsdtar .fakebin/tar
   $ show_path
-  cp dune sh unzip
+  basename cp dune sh unzip
   $ (PATH=.fakebin build_pkg foo)