Capture stderr from extracting .tar.zst

lib/tar.js

@@ -22,13 +22,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isZstdAvailable = isZstdAvailable;
 exports.extract = extract;
+exports.extractTarZst = extractTarZst;
 exports.inferCompressionMethod = inferCompressionMethod;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
 const toolrunner_1 = require("@actions/exec/lib/toolrunner");
 const toolcache = __importStar(require("@actions/tool-cache"));
 const safe_which_1 = require("@chrisgavin/safe-which");
+const uuid_1 = require("uuid");
+const actions_util_1 = require("./actions-util");
 const util_1 = require("./util");
 const MIN_REQUIRED_BSD_TAR_VERSION = "3.4.3";
 const MIN_REQUIRED_GNU_TAR_VERSION = "1.31";
@@ -90,21 +98,59 @@ async function isZstdAvailable(logger) {
         return { available: false };
     }
 }
-async function extract(path, compressionMethod) {
+async function extract(tarPath, compressionMethod, tarVersion) {
     switch (compressionMethod) {
         case "gzip":
-            // While we could also ask tar to autodetect the compression method,
-            // we defensively keep the gzip call identical as requesting a gzipped
-            // bundle will soon be a fallback option.
-            return await toolcache.extractTar(path);
+            // Defensively continue to call the toolcache API as requesting a gzipped
+            // bundle may be a fallback option.
+            return await toolcache.extractTar(tarPath);
         case "zstd":
-            // By specifying only the "x" flag, we ask tar to autodetect the
-            // compression method.
-            return await toolcache.extractTar(path, undefined, "x");
+            if (!tarVersion) {
+                throw new Error("Could not determine tar version, which is required to extract a Zstandard archive.");
+            }
+            return await extractTarZst(tarPath, tarVersion);
     }
 }
-function inferCompressionMethod(path) {
-    if (path.endsWith(".tar.gz")) {
+/**
+ * Extract a compressed tar archive
+ *
+ * @param file     path to the tar
+ * @param dest     destination directory. Optional.
+ * @returns        path to the destination directory
+ */
+async function extractTarZst(file, tarVersion) {
+    if (!file) {
+        throw new Error("parameter 'file' is required");
+    }
+    // Create dest
+    const dest = await createExtractFolder();
+    // Initialize args
+    const args = ["-x", "-v"];
+    let destArg = dest;
+    let fileArg = file;
+    if (process.platform === "win32" && tarVersion.type === "gnu") {
+        args.push("--force-local");
+        destArg = dest.replace(/\\/g, "/");
+        // Technically only the dest needs to have `/` but for aesthetic consistency
+        // convert slashes in the file arg too.
+        fileArg = file.replace(/\\/g, "/");
+    }
+    if (tarVersion.type === "gnu") {
+        // Suppress warnings when using GNU tar to extract archives created by BSD tar
+        args.push("--warning=no-unknown-keyword");
+        args.push("--overwrite");
+    }
+    args.push("-C", destArg, "-f", fileArg);
+    await (0, actions_util_1.runTool)(`tar`, args);
+    return dest;
+}
+async function createExtractFolder() {
+    const dest = path_1.default.join((0, actions_util_1.getTemporaryDirectory)(), (0, uuid_1.v4)());
+    fs.mkdirSync(dest, { recursive: true });
+    return dest;
+}
+function inferCompressionMethod(tarPath) {
+    if (tarPath.endsWith(".tar.gz")) {
         return "gzip";
     }
     return "zstd";