Add xz decompression support for Heavy Toolchain

Author: timothyschoen

Source/Heavy/Toolchain.h

@@ -8,6 +8,8 @@
 #pragma clang diagnostic push
 
 #include <juce_gui_basics/juce_gui_basics.h>
+#include <xz/src/liblzma/api/lzma.h>
+#include <fstream>
 #include "Constants.h"
 
 struct Toolchain {
@@ -148,12 +150,14 @@ class ToolchainInstaller final : public Component
             String downloadLocation = "https://github.com/plugdata-team/plugdata-heavy-toolchain/releases/download/v" + latestVersion + "/";
 
 #if JUCE_MAC
-            downloadLocation += "Heavy-MacOS-Universal.zip";
+            downloadLocation += "Heavy-MacOS-Universal.tar.xz";
 #elif JUCE_WINDOWS
-            downloadLocation += "Heavy-Win64.zip";
+            downloadLocation += "Heavy-Win64.tar.xz";
 #elif JUCE_LINUX && !__aarch64__
-            downloadLocation += "Heavy-Linux-x64.zip";
+            downloadLocation += "Heavy-Linux-x64.tar.xz";
 #endif
+            // for testing, you can set a local archive path here
+            //downloadLocation = "file://Users/timothy/Downloads/Heavy-MacOS-Universal.tar.xz";
 
             instream = URL(downloadLocation).createInputStream(URL::InputStreamOptions(URL::ParameterHandling::inAddress).withConnectionTimeoutMs(10000).withStatusCode(&statusCode));
             startThread();
@@ -259,17 +263,105 @@ class ToolchainInstaller final : public Component
 
         startTimer(25);
 
-        MemoryInputStream input(toolchainData, false);
-        ZipFile zip(input);
-
         auto const toolchainDir = ProjectInfo::appDataDir.getChildFile("Toolchain");
 
         if (toolchainDir.exists())
             toolchainDir.deleteRecursively();
 
-        auto const result = zip.uncompressTo(toolchainDir);
+        HeapArray<uint8_t> decompressedToolchain;
+#if JUCE_LINUX || JUCE_WINDOWS
+        decompressedToolchain.reserve(800 * 1024 * 1024);
+#else
+        decompressedToolchain.reserve(500 * 1024 * 1024);
+#endif
+        bool failed = false;
+        {
+            lzma_stream strm = LZMA_STREAM_INIT;
+            if (lzma_stream_decoder(&strm, UINT64_MAX, 0) != LZMA_OK) {
+                failed = true;
+            }
+            else {
+                strm.next_in = reinterpret_cast<const uint8_t*>(toolchainData.getData());
+                strm.avail_in = toolchainData.getSize();
+                
+                uint8_t buffer[8192];
+                lzma_ret ret;
+                
+                do {
+                    strm.next_out = buffer;
+                    strm.avail_out = sizeof(buffer);
+                    
+                    ret = lzma_code(&strm, LZMA_FINISH);
+                    size_t written = sizeof(buffer) - strm.avail_out;
+                    decompressedToolchain.insert(decompressedToolchain.end(), buffer, buffer + written);
+                    
+                    if (ret != LZMA_OK && ret != LZMA_STREAM_END) {
+                        failed = true;
+                        lzma_end(&strm);
+                    }
+                } while (ret != LZMA_STREAM_END);
+                
+                lzma_end(&strm);
+            }
+        }
 
-        if (!result.wasOk() || statusCode >= 400) {
+        // Parse and extract .tar
+        // TODO: we do this a few times inline, move it into a helper function along with the xz decompression
+        auto extractTar = [](const uint8_t* data, size_t size, const File& destRoot) -> bool {
+            size_t offset = 0;
+            while (offset + 512 <= size) {
+                const uint8_t* header = data + offset;
+                if (header[0] == '\0') break; // End of archive
+
+                // Get file name
+                std::string name(reinterpret_cast<const char*>(header), 100);
+                if (name.empty()) break;
+                
+#if !JUCE_WINDOWS
+                mode_t mode = static_cast<mode_t>(
+                    std::strtoul(reinterpret_cast<const char*>(header + 100), nullptr, 8)
+                );
+                bool executable = (mode & 0100) || (mode & 0010) || (mode & 0001);
+#endif
+                // Get file size (octal)
+                size_t fileSize = std::strtoull(reinterpret_cast<const char*>(header + 124), nullptr, 8);
+                File outFile = destRoot.getChildFile(String(name));
+
+                // Determine type
+                char typeFlag = header[156];
+                if (typeFlag == '5') {
+                    outFile.createDirectory();
+#if !JUCE_WINDOWS
+                    outFile.setExecutePermission(executable);
+#endif
+                } else if (typeFlag == '0' || typeFlag == '\0') {
+                    outFile.getParentDirectory().createDirectory();
+                    std::ofstream out(outFile.getFullPathName().toRawUTF8(), std::ios::binary);
+                    size_t fileOffset = offset + 512;
+                    out.write(reinterpret_cast<const char*>(data + fileOffset), fileSize);
+                    
+                    if (!out.good()) {
+                        out.close();
+                        outFile.deleteFile(); // cleanup partial file
+                        return false;
+                    }
+                    out.close();
+#if !JUCE_WINDOWS
+                    outFile.setExecutePermission(executable);
+#endif
+                }
+
+                size_t totalEntrySize = 512 + ((fileSize + 511) & ~511); // pad to next 512
+                offset += totalEntrySize;
+            }
+            return true;
+        };
+        
+        if(!extractTar(decompressedToolchain.data(), decompressedToolchain.size(), toolchainDir)) {
+            failed = true;
+        }
+        
+        if (failed || statusCode >= 400) {
             MessageManager::callAsync([this] {
                 installButton.topText = "Try Again";
                 errorMessage = "Error: Could not extract downloaded package";
@@ -278,28 +370,8 @@ class ToolchainInstaller final : public Component
             });
             return;
         }
-
-        // Make sure downloaded files have executable permission on unix
-#if JUCE_MAC || JUCE_LINUX || JUCE_BSD
-
-        auto const& tcPath = Toolchain::dir.getFullPathName();
-        auto const permissionsScript = String("#!/bin/bash")
-            + "\nchmod +x " + tcPath + "/bin/Heavy/Heavy"
-            + "\nchmod +x " + tcPath + "/bin/*"
-            + "\nchmod +x " + tcPath + "/lib/dpf/utils/generate-ttl.sh"
-            + "\nchmod +x " + tcPath + "/arm-none-eabi/bin/*"
-            + "\nchmod +x " + tcPath + "/lib/gcc/arm-none-eabi/*/*"
-            + "\nchmod +x " + tcPath + "/lib/OwlProgram/Tools/*"
-#    if JUCE_LINUX
-            + "\nchmod +x " + tcPath + "/x86_64-anywhere-linux-gnu/bin/*"
-            + "\nchmod +x " + tcPath + "/x86_64-anywhere-linux-gnu/sysroot/sbin/*"
-            + "\nchmod +x " + tcPath + "/x86_64-anywhere-linux-gnu/sysroot/usr/bin/*"
-#    endif
-            ;
-
-        Toolchain::startShellScript(permissionsScript);
-
-#elif JUCE_WINDOWS
+        
+#if JUCE_WINDOWS
         File usbDriverInstaller = Toolchain::dir.getChildFile("etc").getChildFile("usb_driver").getChildFile("install-filter.exe");
         File driverSpec = Toolchain::dir.getChildFile("etc").getChildFile("usb_driver").getChildFile("DFU_in_FS_Mode.inf");