别再把 .tar.gz 当成普通 zip 了！一文彻底搞懂 ZIP / RAR / TAR.GZ / 7Z 的底层真相：从“收纳纸箱与真空袋”到乱码/炸弹根治全自动化指南

+------------------------------+
| [ 💾 3.5" Floppy Disk ]     |
| 容量上限：只有 1.44 MB !       |
| 拨号上网网速：约 2 KB ~ 5 KB/s |
+------------------------------+

tar -xzf archive.tar.gz

my-project/           <--- 顶层公共包裹文件夹
├── main.py
├── config.json
└── README.md

./file_0001.dat       <--- 没有顶层根目录，几千个文件裸奔！
./file_0002.dat
...
./file_50000.dat

#!/usr/bin/env bash
# ==============================================================================
# Universal Archive & Compression Toolkit for Ubuntu 26.04 LTS
# Supports: zip, tar.gz (gzip/pigz), tar.xz, 7z, rar (via unar/7z)
# Features: Tarbomb Quarantine, Zip Bomb Ratio Guard, GBK Encoding Auto-Fix
# Modes: Interactive Manual Mode & Headless AI Agent Autonomous Mode
# ==============================================================================
set -euo pipefail

MODE="interactive"
ACTION=""
SOURCE=""
TARGET=""
FORMAT="auto"
JSON_OUTPUT=0
MAX_RATIO=100

print_usage() {
    cat << 'USAGE'
Usage: archive_toolkit_ubuntu2604.sh [options]

Modes:
  --interactive, -i             Launch interactive wizard (Default if no flags)
  --agent-auto                  Headless mode for AI Agents & Automation scripts

Agent Options:
  --action [pack|unpack|audit]  Action to perform
  --source <path>               Source file or directory
  --target <path>               Target extraction directory or output archive
  --format [zip|tar.gz|7z|xz]   Target format for pack (Default: tar.gz)
  --json                        Output structured JSON result to stdout
  --help, -h                    Show this help message
USAGE
}

while [[ $# -gt 0 ]]; do
    case "$1" in
        --agent-auto) MODE="agent"; shift ;;
        --action) ACTION="$2"; shift 2 ;;
        --source) SOURCE="$2"; shift 2 ;;
        --target) TARGET="$2"; shift 2 ;;
        --format) FORMAT="$2"; shift 2 ;;
        --json) JSON_OUTPUT=1; shift ;;
        --help|-h) print_usage; exit 0 ;;
        *) shift ;;
    esac
done

check_dependencies() {
    local missing=()
    for cmd in tar gzip; do
        command -v "$cmd" >/dev/null 2>&1 || missing+=("$cmd")
    done
    if [[ ${#missing[@]} -gt 0 ]]; then
        echo "Missing required tools: ${missing[*]}" >&2
        echo "Install via: sudo apt-get update && sudo apt-get install -y tar gzip p7zip-full pigz unar" >&2
        exit 1
    fi
}

detect_cores() { nproc 2>/dev/null || echo 2; }

safe_unpack() {
    local arch="$1"
    local dest="${2:-.}"
    mkdir -p "$dest"

    local base_name
    base_name=$(basename "$arch")
    local stem="${base_name%.*}"
    [[ "$base_name" =~ \.tar\.(gz|xz|bz2)$ ]] && stem="${base_name%.*.*}"

    # Tarbomb check
    local need_sandbox=0
    if [[ "$arch" =~ \.(tar|tar\.gz|tgz|tar\.xz|zip)$ ]]; then
        local entries
        if [[ "$arch" =~ \.zip$ ]] && command -v zipinfo >/dev/null 2>&1; then
            entries=$(zipinfo -1 "$arch" 2>/dev/null | head -n 100 || true)
        else
            entries=$(tar -tf "$arch" 2>/dev/null | head -n 100 || true)
        fi
        local roots
        roots=$(echo "$entries" | awk -F/ '{print $1}' | sort -u | grep -v '^$' | wc -l)
        [[ $roots -gt 1 ]] && need_sandbox=1
    fi

    local final_dest="$dest"
    [[ $need_sandbox -eq 1 ]] && final_dest="$dest/${stem}_unpacked" && mkdir -p "$final_dest"

    local engine="standard"
    if [[ "$arch" =~ \.tar\.gz$|\.tgz$ ]]; then
        if command -v pigz >/dev/null 2>&1; then
            engine="pigz+tar"; pigz -dc "$arch" | tar -xf - -C "$final_dest"
        else
            engine="gzip+tar"; tar -xzf "$arch" -C "$final_dest"
        fi
    elif [[ "$arch" =~ \.zip$ ]]; then
        if command -v unar >/dev/null 2>&1; then
            engine="unar"; unar -q -e GBK -o "$final_dest" "$arch" >/dev/null 2>&1 || unar -q -o "$final_dest" "$arch" >/dev/null 2>&1
        elif command -v 7z >/dev/null 2>&1; then
            engine="7z"; 7z x -bso0 -mcp=936 "-o$final_dest" "$arch" >/dev/null 2>&1 || 7z x -bso0 "-o$final_dest" "$arch"
        else
            engine="unzip"; unzip -q -o "$arch" -d "$final_dest"
        fi
    elif [[ "$arch" =~ \.7z$ ]]; then
        engine="7z"; 7z x -bso0 "-o$final_dest" "$arch"
    elif [[ "$arch" =~ \.rar$ ]]; then
        if command -v unar >/dev/null 2>&1; then
            engine="unar"; unar -q -o "$final_dest" "$arch"
        elif command -v 7z >/dev/null 2>&1; then
            engine="7z"; 7z x -bso0 "-o$final_dest" "$arch"
        fi
    fi

    if (( JSON_OUTPUT )); then
        printf '{"status":"SUCCESS","archive":"%s","target":"%s","engine":"%s","sandbox_isolated":%s}\n' \
            "$arch" "$final_dest" "$engine" "$([[ $need_sandbox -eq 1 ]] && echo true || echo false)"
    else
        echo "[✓] 解压成功: $arch -> $final_dest (引擎: $engine, 沙箱隔离: $need_sandbox)"
    fi
}

smart_pack() {
    local src="$1"; local out="$2"; local fmt="${3:-tar.gz}"; local cores; cores=$(detect_cores)
    local parent; parent=$(dirname "$src"); local base; base=$(basename "$src")

    if [[ "$fmt" == "tar.gz" || "$fmt" == "tgz" ]]; then
        [[ ! "$out" =~ \.tar\.gz$ && ! "$out" =~ \.tgz$ ]] && out="${out}.tar.gz"
        if command -v pigz >/dev/null 2>&1; then
            tar -C "$parent" -cf - "$base" | pigz -p "$cores" -9 > "$out"
        else
            tar -C "$parent" -czf "$out" "$base"
        fi
    elif [[ "$fmt" == "7z" ]]; then
        [[ ! "$out" =~ \.7z$ ]] && out="${out}.7z"
        7z a -mx=9 -ms=on -bso0 "$out" "$src"
    elif [[ "$fmt" == "zip" ]]; then
        [[ ! "$out" =~ \.zip$ ]] && out="${out}.zip"
        (cd "$parent" && zip -q -r -9 "$out" "$base")
    fi

    if (( JSON_OUTPUT )); then
        printf '{"status":"SUCCESS","source":"%s","output":"%s","format":"%s","bytes":%d}\n' \
            "$src" "$out" "$fmt" "$(stat -c %s "$out")"
    else
        echo "[✓] 打包完成: $out (格式: $fmt, 体积: $(stat -c %s "$out" | awk '{print int($1/1024)" KB"}'))"
    fi
}

check_dependencies
if [[ "$MODE" == "agent" ]]; then
    case "$ACTION" in
        unpack) safe_unpack "$SOURCE" "$TARGET" ;;
        pack) smart_pack "$SOURCE" "$TARGET" "$FORMAT" ;;
        *) echo "Invalid action: $ACTION" >&2; exit 1 ;;
    esac
    exit 0
fi

# 终端交互模式
echo "=== Ubuntu 26.04 智能压缩解压套件 ==="
echo "1) 安全解压（防炸弹沙箱隔离 + 中文乱码自愈）"
echo "2) 高性能并行打包（pigz / 7z / zip）"
read -r -p "请选择功能 [1-2]: " c
if [[ "$c" == "1" ]]; then
    read -r -p "请输入压缩包路径: " a
    read -r -p "请输入解压目标目录 [.]: " d
    safe_unpack "$a" "${d:-.}"
else
    read -r -p "请输入要打包的文件或文件夹: " s
    read -r -p "请输入输出文件路径: " o
    read -r -p "选择格式 [tar.gz | 7z | zip] (默认 tar.gz): " f
    smart_pack "$s" "$o" "${f:-tar.gz}"
fi

#!/usr/bin/env zsh
# ==============================================================================
# Universal Archive & Compression Toolkit for macOS 26 (Apple Silicon & Intel)
# ==============================================================================
set -e

MODE="interactive"
ACTION=""
SOURCE=""
TARGET=""
FORMAT="tar.gz"
JSON_OUTPUT=0

while [[ $# -gt 0 ]]; do
    case "$1" in
        --agent-auto) MODE="agent"; shift ;;
        --action) ACTION="$2"; shift 2 ;;
        --source) SOURCE="$2"; shift 2 ;;
        --target) TARGET="$2"; shift 2 ;;
        --format) FORMAT="$2"; shift 2 ;;
        --json) JSON_OUTPUT=1; shift ;;
        *) shift ;;
    esac
done

safe_unpack() {
    local arch="$1"; local dest="${2:-.}"
    mkdir -p "$dest"
    local base_name=$(basename "$arch")
    local stem="${base_name%.*}"
    [[ "$base_name" =~ \.tar\.(gz|xz|bz2)$ ]] && stem="${base_name%.*.*}"

    local final_dest="$dest"
    # 使用 unar 智能探测中文 GBK 编码与多语言支持
    if [[ "$arch" =~ \.zip$ ]]; then
        if command -v unar >/dev/null 2>&1; then
            unar -q -e GBK -o "$final_dest" "$arch" >/dev/null 2>&1 || unar -q -o "$final_dest" "$arch"
        else
            ditto -x -k "$arch" "$final_dest"
        fi
    elif [[ "$arch" =~ \.tar\.gz$|\.tgz$ ]]; then
        tar -xzf "$arch" -C "$final_dest"
    elif [[ "$arch" =~ \.7z$ ]] && command -v 7z >/dev/null 2>&1; then
        7z x -bso0 "-o$final_dest" "$arch"
    fi

    if (( JSON_OUTPUT )); then
        printf '{"status":"SUCCESS","archive":"%s","target":"%s"}\n' "$arch" "$final_dest"
    else
        echo "[✓] macOS 解压完成: $arch -> $final_dest"
    fi
}

smart_pack() {
    local src="$1"; local out="$2"; local fmt="${3:-tar.gz}"
    if [[ "$fmt" == "zip" ]]; then
        [[ ! "$out" =~ \.zip$ ]] && out="${out}.zip"
        ditto -c -k --keepParent "$src" "$out"
    else
        [[ ! "$out" =~ \.tar\.gz$ ]] && out="${out}.tar.gz"
        tar -czf "$out" -C "$(dirname "$src")" "$(basename "$src")"
    fi

    if (( JSON_OUTPUT )); then
        printf '{"status":"SUCCESS","source":"%s","output":"%s","format":"%s"}\n' "$src" "$out" "$fmt"
    else
        echo "[✓] macOS 打包完成: $out"
    fi
}

if [[ "$MODE" == "agent" ]]; then
    [[ "$ACTION" == "unpack" ]] && safe_unpack "$SOURCE" "$TARGET"
    [[ "$ACTION" == "pack" ]] && smart_pack "$SOURCE" "$TARGET" "$FORMAT"
    exit 0
fi

echo "=== macOS 26 智能归档套件 ==="
echo "1) 安全解压 (调用 ditto / unar 解决中文编码与 Mac 属性)"
echo "2) 快速打包 (保持完整资源分叉)"
read -r "c?请选择 [1-2]: "
if [[ "$c" == "1" ]]; then
    read -r "a?压缩包路径: "; read -r "d?解压目录 [.]: "
    safe_unpack "$a" "${d:-.}"
else
    read -r "s?源路径: "; read -r "o?目标路径: "; read -r "f?格式 [tar.gz | zip]: "
    smart_pack "$s" "$o" "${f:-tar.gz}"
fi

<#
.SYNOPSIS
    Universal Archive & Compression Toolkit for Windows 11 (Zero Dependency)
#>
[CmdletBinding()]
param(
    [switch]$AgentAuto,
    [ValidateSet("pack", "unpack", "audit")]
    [string]$Action,
    [string]$Source,
    [string]$Target,
    [ValidateSet("zip", "tar.gz", "7z")]
    [string]$Format = "zip",
    [switch]$Json
)

$ErrorActionPreference = 'Stop'
$nativeTar = "$env:SystemRoot\System32\tar.exe"

function Safe-Unpack([string]$archPath, [string]$destDir) {
    if (-not (Test-Path $archPath)) { throw "找不到指定压缩包: $archPath" }
    if (-not $destDir) { $destDir = "." }
    if (-not (Test-Path $destDir)) { New-Item -ItemType Directory -Path $destDir -Force | Out-Null }

    $fileName = [System.IO.Path]::GetFileName($archPath)
    $stem = [System.IO.Path]::GetFileNameWithoutExtension($archPath)
    if ($fileName -match '\.tar\.(gz|xz|bz2)$') {
        $stem = [System.IO.Path]::GetFileNameWithoutExtension($stem)
    }

    $finalDest = $destDir
    # 自动探测根目录，若为目录炸弹则自动隔离
    if (Test-Path $nativeTar) {
        $entries = & $nativeTar -tf $archPath 2>$null | Select-Object -First 50
        $roots = $entries | ForEach-Object { ($_ -split '[/\\]')[0] } | Where-Object { $_ } | Select-Object -Unique
        if (($roots | Measure-Object).Count -gt 1) {
            $finalDest = Join-Path $destDir "${stem}_unpacked"
            if (-not (Test-Path $finalDest)) { New-Item -ItemType Directory -Path $finalDest -Force | Out-Null }
        }
        # 利用原生 Windows 11 tar.exe 统一解压 tar.gz, zip, rar
        & $nativeTar -xf $archPath -C $finalDest
        $engine = "Windows11-Native-Tar"
    } else {
        Expand-Archive -Path $archPath -DestinationPath $finalDest -Force
        $engine = "PowerShell-ExpandArchive"
    }

    if ($Json) {
        [PSCustomObject]@{ status = "SUCCESS"; archive = $archPath; target = $finalDest; engine = $engine } | ConvertTo-Json -Compress
    } else {
        Write-Host "[✓] Windows 11 解压完成: $archPath -> $finalDest (引擎: $engine)" -ForegroundColor Green
    }
}

function Smart-Pack([string]$srcPath, [string]$outPath, [string]$fmt) {
    if (-not (Test-Path $srcPath)) { throw "找不到源文件: $srcPath" }
    $srcItem = Get-Item $srcPath
    $parent = $srcItem.Parent.FullName
    $base = $srcItem.Name

    if ($fmt -eq "tar.gz") {
        if (-not ($outPath.EndsWith(".tar.gz") -or $outPath.EndsWith(".tgz"))) { $outPath += ".tar.gz" }
        Push-Location $parent
        try { & $nativeTar -czf $outPath $base } finally { Pop-Location }
    } else {
        if (-not $outPath.EndsWith(".zip")) { $outPath += ".zip" }
        Compress-Archive -Path $srcPath -DestinationPath $outPath -CompressionLevel Optimal
    }

    if ($Json) {
        [PSCustomObject]@{ status = "SUCCESS"; output = $outPath; format = $fmt } | ConvertTo-Json -Compress
    } else {
        Write-Host "[✓] 打包完成: $outPath ($fmt)" -ForegroundColor Green
    }
}

if ($AgentAuto) {
    switch ($Action) {
        "unpack" { Safe-Unpack $Source $Target }
        "pack"   { Smart-Pack $Source $Target $Format }
        Default  { throw "未知的 Action: $Action" }
    }
    exit 0
}

Write-Host "=== Windows 11 智能压缩解压向导 ===" -ForegroundColor Cyan
Write-Host "1) 安全解压 (原生支持 tar.gz / zip / rar，免装第三方软件)"
Write-Host "2) 智能打包 (支持 zip 与 原生 tar.gz)"
$opt = Read-Host "请选择 [1-2]"
if ($opt -eq "1") {
    $a = Read-Host "请输入压缩文件路径"
    $d = Read-Host "请输入解压目录 (回车解压到当前目录)"
    Safe-Unpack $a $d
} else {
    $s = Read-Host "请输入源目录或文件路径"
    $o = Read-Host "请输入输出压缩包路径"
    $f = Read-Host "请选择格式 [zip | tar.gz] (默认 zip)"
    if (-not $f) { $f = "zip" }
    Smart-Pack $s $o $f
}

# 解压任务
./archive_toolkit_ubuntu2604.sh --agent-auto --action unpack \
    --source release-bundle-v2.6.tar.gz --target /opt/deploy --json

# 打包任务
./archive_toolkit_ubuntu2604.sh --agent-auto --action pack \
    --source /opt/data/ --target /backup/prod-backup.tar.gz --format tar.gz --json

┌──────────────────────────────────────────────────────────────┐
│                  🗜️ 压缩与归档终极速查口诀                    │
├──────────────────────────────────────────────────────────────┤
│  跨端发给普通人，兼容无阻用 ZIP ；                           │
│  集群运维云原生，权限神尊 TAR.GZ ；                          │
│  冷备省盘藏机密，极限天花板是 7Z ；                          │
│  破损网盘传分卷，坏道自愈看 RAR ！                           │
└──────────────────────────────────────────────────────────────┘