Tar Archive Handler (cpp, written by Codex)

Codex wrote this cpp project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Tar Archive Handler

Write a program that creates, extracts, lists, and manipulates TAR archives with support for multiple compression methods (gzip, bzip2, xz), preserving file permissions and ownership metadata.

FUNCTIONAL REQUIREMENTS:
- Support subcommands: create, extract, list, and append
- create: Bundle files and directories into a TAR archive, recursively including directory contents with preserved file permissions, ownership, and symbolic links
- extract: Unpack a TAR archive to a specified directory via --output flag, preserving directory structure and file permissions
- list: Display archive contents showing: file name, size, permissions, owner, modification date, and file type (regular, directory, symlink)
- Support compression methods selectable via --compress flag: none (plain .tar), gzip (.tar.gz), bzip2 (.tar.bz2), xz (.tar.xz); auto-detect during extraction
- append: Add files to an existing uncompressed TAR archive
- Support file filtering via --include and --exclude flags with glob patterns
- Support extracting specific files from an archive by listing their paths as additional arguments
- Verify archive integrity via --verify flag
- Print operation summary to console: total files, total size, compression ratio (if compressed), and processing time
- Save operation log as JSON with --log flag
- If no arguments are given, create a sample directory structure with files of various types, create archives in each compression format, list contents of each, extract one, and compare compression ratios
- Handle errors: corrupted archives, unsupported formats, path traversal attacks, and permission issues during extraction

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.16)
project(tar_archive_handler LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(tar_archive_handler src/main.cpp)

# Tar Archive Handler (C++)

## Requirements
- Ubuntu 22.04
- CMake 3.16+
- C++20 compiler
- System `tar` utility with gzip/bzip2/xz support

## Build
```bash
cmake -S . -B build
cmake --build build
```

## Run
```bash
./build/tar_archive_handler create archive_base input_dir --compress gzip
./build/tar_archive_handler list archive_base.tar.gz
./build/tar_archive_handler extract archive_base.tar.gz --output extracted --verify
./build/tar_archive_handler append archive_base.tar file1 file2
```

If no args are passed, sample archives are generated and demo operations run.

## Notes
This implementation uses host `tar` utilities for archive processing.

#include <chrono>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

namespace fs = std::filesystem;

struct Config {
    std::string cmd;
    std::string compress = "none";
    std::vector<std::string> include;
    std::vector<std::string> exclude;
    std::string output;
    bool verify = false;
    std::string log;
    std::vector<std::string> positional;
};

static std::string quote(const std::string& s) { return "\"" + s + "\""; }

static std::string runCommand(const std::string& cmd) {
#if defined(_WIN32)
    FILE* pipe = _popen(cmd.c_str(), "r");
#else
    FILE* pipe = popen(cmd.c_str(), "r");
#endif
    if (!pipe) throw std::runtime_error("Failed to run command: " + cmd);
    std::ostringstream out;
    char buf[4096];
    while (fgets(buf, sizeof(buf), pipe)) out << buf;
#if defined(_WIN32)
    int rc = _pclose(pipe);
#else
    int rc = pclose(pipe);
#endif
    if (rc != 0) throw std::runtime_error("Command failed: " + cmd + "\n" + out.str());
    return out.str();
}

static Config parseArgs(int argc, char** argv) {
    Config cfg;
    int i = 1;
    if (argc > 1 && std::string(argv[1]).rfind("--", 0) != 0) {
        cfg.cmd = argv[1];
        i = 2;
    }
    for (; i < argc; ++i) {
        std::string a = argv[i];
        if (a == "--compress" && i + 1 < argc) cfg.compress = argv[++i];
        else if (a == "--include" && i + 1 < argc) cfg.include.push_back(argv[++i]);
        else if (a == "--exclude" && i + 1 < argc) cfg.exclude.push_back(argv[++i]);
        else if (a == "--output" && i + 1 < argc) cfg.output = argv[++i];
        else if (a == "--verify") cfg.verify = true;
        else if (a == "--log" && i + 1 < argc) cfg.log = argv[++i];
        else if (a.rfind("--", 0) == 0) throw std::runtime_error("Unknown option: " + a);
        else cfg.positional.push_back(a);
    }
    return cfg;
}

static std::string compFlag(const std::string& c) {
    if (c == "gzip") return "z";
    if (c == "bzip2") return "j";
    if (c == "xz") return "J";
    return "";
}

static std::string defaultArchive(const std::string& base, const std::string& c) {
    if (c == "gzip") return base + ".tar.gz";
    if (c == "bzip2") return base + ".tar.bz2";
    if (c == "xz") return base + ".tar.xz";
    return base + ".tar";
}

static std::vector<std::string> splitLines(const std::string& s) {
    std::vector<std::string> out;
    std::stringstream ss(s);
    std::string line;
    while (std::getline(ss, line)) if (!line.empty()) out.push_back(line);
    return out;
}

static std::string createArchive(const Config& cfg) {
    if (cfg.positional.size() < 2) throw std::runtime_error("Usage: create <archive_base_or_path> <file|dir> [...]");
    std::string archive = cfg.output.empty() ? defaultArchive(cfg.positional[0], cfg.compress) : cfg.output;

    std::ostringstream cmd;
    cmd << "tar -c" << compFlag(cfg.compress) << "f " << quote(archive) << " ";
    for (const auto& ex : cfg.exclude) cmd << "--exclude=" << quote(ex) << " ";
    for (size_t i = 1; i < cfg.positional.size(); ++i) cmd << quote(cfg.positional[i]) << " ";

    std::string out = runCommand(cmd.str());
    auto list = runCommand("tar -tvf " + quote(archive));
    out += "\n" + list;
    return out;
}

static std::string extractArchive(const Config& cfg) {
    if (cfg.positional.empty()) throw std::runtime_error("Usage: extract <archive> [path ...]");
    std::string archive = cfg.positional[0];
    std::string outDir = cfg.output.empty() ? "." : cfg.output;
    fs::create_directories(outDir);

    std::ostringstream cmd;
    cmd << "tar -xf " << quote(archive) << " -C " << quote(outDir) << " ";
    for (size_t i = 1; i < cfg.positional.size(); ++i) cmd << quote(cfg.positional[i]) << " ";

    std::string out = runCommand(cmd.str());
    if (cfg.verify) out += "\n" + runCommand("tar -tf " + quote(archive));
    return out;
}

static std::string listArchive(const Config& cfg) {
    if (cfg.positional.empty()) throw std::runtime_error("Usage: list <archive>");
    return runCommand("tar -tvf " + quote(cfg.positional[0]));
}

static std::string appendArchive(const Config& cfg) {
    if (cfg.positional.size() < 2) throw std::runtime_error("Usage: append <archive.tar> <file|dir> [...]");
    std::string archive = cfg.positional[0];
    if (archive.size() < 4 || archive.substr(archive.size() - 4) != ".tar") throw std::runtime_error("append supports only uncompressed .tar archives");

    std::ostringstream cmd;
    cmd << "tar -rf " << quote(archive) << " ";
    for (size_t i = 1; i < cfg.positional.size(); ++i) cmd << quote(cfg.positional[i]) << " ";

    std::string out = runCommand(cmd.str());
    out += "\n" + runCommand("tar -tvf " + quote(archive));
    return out;
}

static void writeSample() {
    fs::path root = "sample_tar_data";
    fs::remove_all(root);
    fs::create_directories(root / "docs");
    fs::create_directories(root / "assets");

    std::ofstream(root / "docs" / "readme.txt") << "Sample tar data\n";
    std::ofstream(root / "docs" / "table.csv") << "id,name\n1,A\n2,B\n";
    std::ofstream(root / "assets" / "blob.bin", std::ios::binary) << std::string(2048, '\x1f');
}

int main(int argc, char** argv) {
    try {
        Config cfg = parseArgs(argc, argv);
        if (cfg.cmd.empty()) {
            writeSample();
            std::cout << "No args: running demo\n";
            Config c; c.cmd = "create"; c.compress = "gzip"; c.positional = {"sample_gzip", "sample_tar_data"};
            std::cout << createArchive(c) << "\n";
            Config l; l.cmd = "list"; l.positional = {"sample_gzip.tar.gz"};
            std::cout << listArchive(l) << "\n";
            Config e; e.cmd = "extract"; e.output = "sample_tar_extract"; e.verify = true; e.positional = {"sample_gzip.tar.gz"};
            std::cout << extractArchive(e) << "\n";
            return 0;
        }

        auto start = std::chrono::steady_clock::now();
        std::string output;
        if (cfg.cmd == "create") output = createArchive(cfg);
        else if (cfg.cmd == "extract") output = extractArchive(cfg);
        else if (cfg.cmd == "list") output = listArchive(cfg);
        else if (cfg.cmd == "append") output = appendArchive(cfg);
        else throw std::runtime_error("Unknown command: " + cfg.cmd);

        std::cout << output << "\n";
        double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
        std::cout << "Time: " << ms << " ms\n";

        std::string logPath = !cfg.log.empty() ? cfg.log : (cfg.cmd == "list" ? "" : "tar_operation_log.json");
        if (!logPath.empty()) {
            std::ofstream out(logPath);
            out << "{\n"
                << "  \"command\": \"" << cfg.cmd << "\",\n"
                << "  \"elapsedMs\": " << ms << ",\n"
                << "  \"output\": " << quote(output) << "\n"
                << "}\n";
        }
    } catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << "\n";
        return 1;
    }
    return 0;
}