sdk_tools.cpp

浏览该文件的文档.

#include "cmdline/sdk_tools.h"
#include "cmdline/Sha256.h"
 
#include "common/config.h"
 
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
 
#include <zlib.h>
 
#if defined(_WIN32)
#include <windows.h>
#include <process.h>
#else
#include <unistd.h>
#endif
 
#if !defined(_WIN32)
#include <sys/wait.h>
#endif
 
namespace eve::cmd::sdk {
 
namespace {
 
std::string lower(std::string s) {
    for (char& c : s)
        if (c >= 'A' && c <= 'Z') c = static_cast<char>(c - 'A' + 'a');
    return s;
}
 
int processId() {
#if defined(_WIN32)
    return _getpid();
#else
    return static_cast<int>(getpid());
#endif
}
 
[[nodiscard]] 
bool nonEmptyRegularFile(const std::filesystem::path& path, std::error_code& ec) {
    ec.clear();
    if (!std::filesystem::is_regular_file(path, ec) || ec) return false;
    const auto size = std::filesystem::file_size(path, ec);
    return !ec && size > 0;
}
 
// 校验 zip 条目路径安全：拒绝绝对路径与 ".."/"." 组件（zip-slip 防护）。
bool zipEntryPathSafe(const std::string& name) {
    if (name.empty()) return false;
    if (name[0] == '/' || name[0] == '\\') return false;
    std::string comp;
    for (const char c : name) {
        if (c == '/' || c == '\\') {
            if (comp == ".." || comp == ".") return false;
            comp.clear();
        } else {
            comp += c;
        }
    }
    return comp != ".." && comp != ".";
}
 
// 进程内 ZIP 解压（STORED + DEFLATE）：宿主 tar 不一定能读 zip（Linux 的
// GNU tar 就不支持），而 SDK 安装不能要求用户机器预装 unzip/bsdtar。
bool extractZip(const std::string& zipPath, const std::string& destDir) {
    std::ifstream in(zipPath, std::ios::binary);
    if (!in) return false;
    const std::vector<char> data((std::istreambuf_iterator<char>(in)),
                                 std::istreambuf_iterator<char>());
    if (data.size() < 22) return false;
 
    const auto le16 = [&](size_t off) -> uint16_t {
        return static_cast<uint16_t>(static_cast<unsigned char>(data[off]) |
                                     (static_cast<unsigned char>(data[off + 1]) << 8));
    };
    const auto le32 = [&](size_t off) -> uint32_t {
        return static_cast<uint32_t>(static_cast<unsigned char>(data[off]) |
                                     (static_cast<unsigned char>(data[off + 1]) << 8) |
                                     (static_cast<unsigned char>(data[off + 2]) << 16) |
                                     (static_cast<unsigned char>(data[off + 3]) << 24));
    };
 
    // EOCD 在文件末尾 64KB+22 字节内。
    size_t eocd = std::string::npos;
    const size_t searchStart = data.size() > 65557 ? data.size() - 65557 : 0;
    for (size_t i = data.size() - 22;; --i) {
        if (data[i] == 'P' && data[i + 1] == 'K' && data[i + 2] == 5 && data[i + 3] == 6) {
            eocd = i;
            break;
        }
        if (i == searchStart) break;
    }
    if (eocd == std::string::npos) return false;
    const uint32_t cdOffset = le32(eocd + 16);
    const uint32_t cdSize = le32(eocd + 12);
    if (cdOffset > data.size() || cdSize > data.size() - cdOffset) return false;
 
    size_t pos = cdOffset;
    const size_t cdEnd = cdOffset + cdSize;
    while (cdEnd - pos >= 46 && data[pos] == 'P' && data[pos + 1] == 'K' && data[pos + 2] == 1 && data[pos + 3] == 2) {
        const size_t   entryStart = pos;
        const uint16_t method = le16(pos + 10);
        const uint32_t entryCrc   = le32(pos + 16);
        const uint32_t compSz = le32(pos + 20);
        const uint32_t uncompSz = le32(pos + 24);
        const uint16_t nameLen = le16(pos + 28);
        const uint16_t extraLen = le16(pos + 30);
        const uint16_t commentLen = le16(pos + 32);
        const uint32_t localOff = le32(pos + 42);
        const size_t   entrySize  = static_cast<size_t>(46) + nameLen + extraLen + commentLen;
        if (entrySize > cdEnd - pos) return false;
        const std::string name(data.data() + entryStart + 46, nameLen);
        // Read the central-directory attributes before advancing to the next entry.
        // Reading them from `pos` after the increment was the vector overrun seen
        // when installing the local release fixture.
#if !defined(_WIN32)
        const uint32_t extAttr = le32(entryStart + 38);
#endif
        pos += entrySize;
 
        if (!zipEntryPathSafe(name)) return false;
        const bool isDir = !name.empty() && name.back() == '/';
        const auto dest = std::filesystem::path(destDir) / name;
        std::error_code ec;
        if (isDir) {
            std::filesystem::create_directories(dest, ec);
            continue;
        }
        if (localOff > data.size() || data.size() - localOff < 30 || data[localOff] != 'P' ||
            data[localOff + 1] != 'K' || data[localOff + 2] != 3 || data[localOff + 3] != 4)
            return false;
        const size_t localHeaderSize = static_cast<size_t>(30) + le16(localOff + 26) + le16(localOff + 28);
        if (localHeaderSize > data.size() - localOff) return false;
        const size_t lData = localOff + localHeaderSize;
        if (compSz > data.size() - lData || compSz > static_cast<uint32_t>(std::numeric_limits<uInt>::max()))
            return false;
 
        std::vector<char> out;
        if (method == 0) {
            out.assign(data.begin() + static_cast<ptrdiff_t>(lData),
                       data.begin() + static_cast<ptrdiff_t>(lData + compSz));
        } else if (method == 8) {
            z_stream zs = {};
            if (inflateInit2(&zs, -15) != Z_OK) return false;
            zs.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(data.data() + lData));
            zs.avail_in = static_cast<uInt>(compSz);
            std::vector<char> buf(65536);
            int ret;
            do {
                zs.next_out = reinterpret_cast<Bytef*>(buf.data());
                zs.avail_out = static_cast<uInt>(buf.size());
                ret = inflate(&zs, Z_NO_FLUSH);
                if (ret != Z_OK && ret != Z_STREAM_END) {
                    inflateEnd(&zs);
                    return false;
                }
                out.insert(out.end(), buf.begin(), buf.end() - zs.avail_out);
            } while (ret != Z_STREAM_END);
            inflateEnd(&zs);
        } else {
            return false;  // 不支持的方法（zip 里极罕见）。
        }
        if (out.size() != uncompSz) return false;
        if (static_cast<uint32_t>(
                crc32(0, reinterpret_cast<const Bytef*>(out.data()), static_cast<uInt>(out.size()))) != entryCrc)
            return false;
 
        std::filesystem::create_directories(dest.parent_path(), ec);
        if (ec) return false;
        std::ofstream ofs(dest, std::ios::binary | std::ios::trunc);
        if (!ofs) return false;
        ofs.write(out.data(), static_cast<std::streamsize>(out.size()));
        if (!ofs) return false;
#if !defined(_WIN32)
        // Preserve the unix mode recorded in the zip's external attributes
        // (bits 16-23) so extracted tools stay executable: gradle, sdkmanager,
        // aapt/adb all ship as scripts/binaries with +x in their archives.
        const auto mode = static_cast<unsigned>((extAttr >> 16) & 0xFFFF);
        if (mode & 0111) {
            std::error_code pec;
            std::filesystem::permissions(dest,
                std::filesystem::perms::owner_exec | std::filesystem::perms::group_exec |
                    std::filesystem::perms::others_exec,
                std::filesystem::perm_options::add, pec);
        }
#endif
    }
    return pos == cdEnd;
}
 
}  // namespace
 
Platform parsePlatform(const std::string& name) {
    const std::string n = lower(name);
    if (n == "android") return Platform::Android;
    if (n == "ios") return Platform::Ios;
    if (n == "linux") return Platform::Linux;
    if (n == "macosx" || n == "macos" || n == "mac" || n == "osx") return Platform::Macosx;
    if (n == "win32" || n == "windows" || n == "win" || n == "win64") return Platform::Win32;
    return Platform::Unknown;
}
 
std::string platformName(Platform p) {
    switch (p) {
        case Platform::Win32: return "win32";
        case Platform::Linux: return "linux";
        case Platform::Macosx: return "macosx";
        case Platform::Android: return "android";
        case Platform::Ios: return "ios";
        default: return "unknown";
    }
}
 
std::string getEnv(const std::string& name, const std::string& def) {
    const char* v = std::getenv(name.c_str());
    return v ? std::string(v) : def;
}
 
void setEnv(const std::string& name, const std::string& value) {
#if defined(_WIN32)
    _putenv_s(name.c_str(), value.c_str());
#else
    setenv(name.c_str(), value.c_str(), 1);
#endif
}
 
std::string sdkVersionTag() {
    const std::string override = getEnv("EVE_SDK_TAG");
    if (!override.empty()) return override;
    std::string v = EVENGINE_VERSION;
    const size_t dash = v.find('-');
    if (dash != std::string::npos) v = v.substr(0, dash);
    if (v.empty()) return "";
    if (v[0] != 'v') v = "v" + v;
    return v;
}
 
std::string eveSdkInstallRoot() {
    const std::string override = getEnv("EVE_SDK_INSTALL_ROOT");
    if (!override.empty()) return override;
#if defined(_WIN32)
    std::string base = getEnv("LOCALAPPDATA");
    if (base.empty()) base = getEnv("USERPROFILE");
    return base.empty() ? std::string("EVEngine/sdk") : base + "/EVEngine/sdk";
#else
    std::string base = getEnv("XDG_DATA_HOME");
    if (base.empty()) {
        const std::string home = getEnv("HOME");
        base = home.empty() ? std::string("") : home + "/.local/share";
    }
    return base.empty() ? std::string("EVEngine/sdk") : base + "/EVEngine/sdk";
#endif
}
 
std::string eveSdkBaseUrl() {
    const std::string override = getEnv("EVE_SDK_BASE_URL");
    if (!override.empty()) return override;
    return std::string("https://github.com/EVEngine/EVEngine/releases/download/") +
           sdkVersionTag();
}
 
std::string fileSha256(const std::string& path) {
    std::ifstream in(path, std::ios::binary);
    if (!in) return "";
    detail::Sha256 digest;
    char           buffer[16384];
    while (in) {
        in.read(buffer, sizeof(buffer));
        if (in.gcount() > 0) digest.update(buffer, static_cast<std::size_t>(in.gcount()));
    }
    if (in.bad()) return "";
    return digest.finish();
}
 
namespace {
 
bool isSdkRoot(const std::filesystem::path& dir) {
    std::error_code ec;
    return std::filesystem::is_regular_file(
        std::filesystem::path(dir) / "share" / "eve" / "TARGET_PLATFORM", ec);
}
 
}  // namespace
 
std::string findSdkRoot(const std::string& sdkArg) {
    std::error_code ec;
    if (!sdkArg.empty()) {
        const auto p = std::filesystem::absolute(sdkArg, ec);
        if (!ec && std::filesystem::is_directory(p, ec)) return p.string();
        return "";
    }
    const std::string env = getEnv("EVENGINE_SDK");
    if (!env.empty() && std::filesystem::is_directory(env, ec))
        return std::filesystem::absolute(env, ec).string();
 
    // Running from <sdk>/bin/<runtime> -> root is two directories up.
#if defined(_WIN32)
    wchar_t buf[MAX_PATH + 1] = {0};
    if (GetModuleFileNameW(nullptr, buf, MAX_PATH) != 0) {
        const auto exeDir = std::filesystem::path(buf).parent_path();
        if (isSdkRoot(exeDir.parent_path())) return exeDir.parent_path().string();
    }
#else
    char buf[4096] = {0};
    const ssize_t n = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
    if (n > 0) {
        const auto exeDir = std::filesystem::path(std::string(buf, static_cast<size_t>(n))).parent_path();
        if (isSdkRoot(exeDir.parent_path())) return exeDir.parent_path().string();
    }
#endif
 
    const auto cwd = std::filesystem::current_path(ec);
    if (!ec && isSdkRoot(cwd)) return cwd.string();
 
    // `eve get <platform>` 安装的 SDK（<installRoot>/<platform>）。优先返回
    // android（build 目前唯一支持的平台），其次任意 SDK 根。
    const auto  installRoot = std::filesystem::path(eveSdkInstallRoot());
    std::string fallback;
    if (std::filesystem::is_directory(installRoot, ec)) {
        std::filesystem::directory_iterator it(installRoot, ec), end;
        for (; it != end; it.increment(ec)) {
            if (ec) {
                ec.clear();
                continue;
            }
            if (!it->is_directory(ec) || !isSdkRoot(it->path())) continue;
            const std::string plat = sdkTargetPlatform(it->path().string());
            if (plat == "android") return it->path().string();
            if (fallback.empty()) fallback = it->path().string();
        }
    }
    return fallback;
}
 
namespace {
 
// 从 SHA256SUMS 文本里找 "<hex>  <name>" 行，返回小写 hex；找不到返回空串。
std::string sha256ForName(const std::string& sums, const std::string& name) {
    std::istringstream iss(sums);
    std::string        line;
    while (std::getline(iss, line)) {
        const size_t sp = line.find(' ');
        if (sp == std::string::npos) continue;
        const std::string hex = line.substr(0, sp);
        std::string       rest = line.substr(sp + 1);
        while (!rest.empty() && (rest.front() == ' ' || rest.front() == '\t'))
            rest.erase(rest.begin());
        while (!rest.empty() &&
               (rest.back() == '\r' || rest.back() == ' ' || rest.back() == '\t'))
            rest.pop_back();
        if (rest == name) return lower(hex);
    }
    return "";
}
 
// 读取 <root>/share/eve/VERSION；文件缺失或为空时返回空串。
std::string sdkVersion(const std::string& root) {
    std::ifstream in(std::filesystem::path(root) / "share" / "eve" / "VERSION");
    std::string   s;
    std::getline(in, s);
    while (!s.empty() && (s.back() == '\r' || s.back() == '\n' || s.back() == ' ')) s.pop_back();
    return s;
}
 
// moveOrCopy 定义在本文件较后位置（下载/解压工具区），这里前向声明。
bool moveOrCopy(const std::filesystem::path& from, const std::filesystem::path& to);
 
}  // namespace
 
eve::Result<void> installEveSdk(Platform p) {
    namespace fs = std::filesystem;
    if (p == Platform::Unknown) return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument, "unknown SDK platform", {}, {}, "cmdline.sdk"));
    const std::string plat = platformName(p);
    const std::string tag = sdkVersionTag();
    if (tag.empty() || tag[0] != 'v') {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument, "cannot determine the current EVEngine version; set EVE_SDK_TAG", "EVE_SDK_TAG", {}, "cmdline.sdk"));
    }
    const std::string expectedVer = tag.substr(1);
    const std::string installRoot = eveSdkInstallRoot();
    const std::string destRoot = (fs::path(installRoot) / plat).string();
    std::error_code  ec;
 
    // 已安装同版本则直接复用，避免重复下载。
    const std::string currentVer = sdkVersion(destRoot);
    if (!currentVer.empty() && currentVer == expectedVer) {
        std::cout << "eve get: EVEngine " << plat << " SDK already installed at "
                  << destRoot << " (" << tag << ")" << std::endl;
        return eve::Result<void>::success();
    }
 
    const std::string base = eveSdkBaseUrl();
    const std::string zipName = "eve-sdk-" + plat + "-" + tag + ".zip";
    const std::string zipUrl = base + "/" + zipName;
    const std::string sumsUrl = base + "/SHA256SUMS";
    const auto work =
        fs::temp_directory_path(ec) / ("eve-get-" + plat + "-" + std::to_string(processId()));
    if (ec) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "no temporary directory available", {}, {}, "cmdline.sdk"));
    }
    fs::remove_all(work, ec);
    fs::create_directories(work, ec);
    if (ec) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create SDK download workspace: " + ec.message(), work.string(), {}, "cmdline.sdk"));
    }
    const std::string zipPath = (work / zipName).string();
    const std::string sumsPath = (work / "SHA256SUMS").string();
 
    std::cout << "eve get: downloading " << zipName << " (" << zipUrl << ")...\n";
    if (runShell("curl -fL --retry 3 -o \"" + zipPath + "\" \"" + zipUrl + "\"") != 0) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "SDK archive download failed", zipUrl, {}, "cmdline.sdk"));
    }
    if (!nonEmptyRegularFile(zipPath, ec)) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "SDK archive download returned an empty or unreadable response", zipUrl, {}, "cmdline.sdk"));
    }
    if (runShell("curl -fL --retry 3 -o \"" + sumsPath + "\" \"" + sumsUrl + "\"") != 0) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "SDK checksum file download failed", sumsUrl, {}, "cmdline.sdk"));
    }
    if (!nonEmptyRegularFile(sumsPath, ec)) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "SDK checksum download returned an empty or unreadable response", sumsUrl, {}, "cmdline.sdk"));
    }
    {
        std::ifstream in(sumsPath);
        const std::string sums(
            (std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
        const std::string expected = sha256ForName(sums, zipName);
        const std::string actual = fileSha256(zipPath);
        if (expected.empty() || actual.empty() || lower(expected) != lower(actual)) {
            fs::remove_all(work, ec);
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::HashMismatch, "SDK SHA-256 verification failed for " + zipName, zipPath, {}, "cmdline.sdk"));
        }
    }
 
    const std::string extractDir = (work / "extract").string();
    fs::create_directories(extractDir, ec);
    if (ec) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create SDK extraction directory: " + ec.message(), extractDir, {}, "cmdline.sdk"));
    }
    if (!extractZip(zipPath, extractDir)) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "SDK archive is empty, truncated, or not a supported ZIP archive", zipPath, {}, "cmdline.sdk"));
    }
    const auto srcRoot = fs::path(extractDir) / "eve-sdk" / plat;
    if (!fs::is_directory(srcRoot, ec)) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "unexpected SDK archive layout; expected eve-sdk/" + plat + "/", zipPath, {}, "cmdline.sdk"));
    }
    {
        const std::string platMarker = sdkTargetPlatform(srcRoot.string());
        const std::string verMarker = sdkVersion(srcRoot.string());
        if (platMarker != plat) {
            fs::remove_all(work, ec);
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument, "SDK archive targets '" + platMarker + "', not '" + plat + "'", (srcRoot / "share" / "eve" / "TARGET_PLATFORM").string(), {}, "cmdline.sdk"));
        }
        if (verMarker != expectedVer) {
            fs::remove_all(work, ec);
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument, "SDK archive contains version '" + verMarker + "', expected '" + expectedVer + "'", (srcRoot / "share" / "eve" / "VERSION").string(), {}, "cmdline.sdk"));
        }
    }
 
    fs::create_directories(installRoot, ec);
    if (ec) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create SDK install directory: " + ec.message(), installRoot, {}, "cmdline.sdk"));
    }
    if (!moveOrCopy(srcRoot, fs::path(destRoot))) {
        fs::remove_all(work, ec);
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "failed to install the SDK", destRoot, {}, "cmdline.sdk"));
    }
    fs::remove_all(work, ec);
    std::cout << "eve get: EVEngine " << plat << " SDK " << tag << " installed at "
              << destRoot << std::endl;
    return eve::Result<void>::success();
}
 
std::string sdkTargetPlatform(const std::string& sdkRoot) {
    std::ifstream in(std::filesystem::path(sdkRoot) / "share" / "eve" / "TARGET_PLATFORM");
    std::string  s;
    std::getline(in, s);
    while (!s.empty() && (s.back() == '\r' || s.back() == '\n' || s.back() == ' ')) s.pop_back();
    return s;
}
 
std::string androidSdkRoot() {
    for (const char* n : {"EVENGINE_ANDROID_SDK", "ANDROID_SDK_ROOT", "ANDROID_HOME"}) {
        const std::string v = getEnv(n);
        if (!v.empty()) return v;
    }
#if defined(_WIN32)
    const std::string local = getEnv("LOCALAPPDATA");
    if (!local.empty()) return local + "/Android/Sdk";
    return getEnv("USERPROFILE") + "/Android/Sdk";
#else
    const std::string home = getEnv("HOME");
    return home.empty() ? std::string("Android/Sdk") : home + "/Android/Sdk";
#endif
}
 
void applyEnvFile(const std::string& path) {
    std::ifstream in(path);
    if (!in) return;
    std::string line;
    while (std::getline(in, line)) {
        if (line.empty() || line[0] == '#') continue;
        const size_t eq = line.find('=');
        if (eq == std::string::npos) continue;
        const std::string key = line.substr(0, eq);
        if (key.empty()) continue;
        if (getEnv(key).empty()) setEnv(key, line.substr(eq + 1));
    }
}
 
int runShell(const std::string& cmd) {
#if defined(EVENGINE_IOS)
    // iOS forbids system(); the shell-out paths (eve get / eve build) are
    // desktop-host only and never run on the iOS runtime.
    std::cerr << "eve: shell commands are not available on iOS: " << cmd << std::endl;
    return 127;
#else
    const int rc = std::system(cmd.c_str());
    if (rc == -1) {
        std::cerr << "eve: failed to run: " << cmd << std::endl;
        return 127;
    }
#if defined(_WIN32)
    return rc;
#else
    if (WIFEXITED(rc)) return WEXITSTATUS(rc);
    return 1;
#endif
#endif
}
 
namespace {
 
std::string exeSuffix() {
#if defined(_WIN32)
    return ".exe";
#else
    return "";
#endif
}
 
// sdkmanager 在 Windows 上是 .bat 脚本，其它平台是无后缀的 sh 脚本。
std::string sdkmanagerSuffix() {
#if defined(_WIN32)
    return ".bat";
#else
    return "";
#endif
}
 
// Google 官方 command-line tools 压缩包（按宿主平台）。可用
// EVE_ANDROID_CMDLINE_TOOLS_URL 覆盖（镜像/测试）。
std::string androidCmdlineToolsUrl() {
#if defined(_WIN32)
    return "https://dl.google.com/android/repository/commandlinetools-win-11076708_latest.zip";
#elif defined(__APPLE__)
    return "https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip";
#else
    return "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip";
#endif
}
 
// Eclipse Temurin JDK 17 直链（Adoptium API 重定向到最新 17 GA）。
// 可用 EVE_JDK17_URL 覆盖（镜像/测试）。
std::string temurinJdk17Url() {
    const char* os;
    const char* arch;
#if defined(_WIN32)
    os = "windows";
    arch = "x64";
#elif defined(__APPLE__)
    os = "mac";
#if defined(__aarch64__)
    arch = "aarch64";
#else
    arch = "x64";
#endif
#else
    os = "linux";
#if defined(__aarch64__)
    arch = "aarch64";
#else
    arch = "x64";
#endif
#endif
    return std::string("https://api.adoptium.net/v3/binary/latest/17/ga/") + os + "/" + arch +
           "/jdk/hotspot/normal/eclipse";
}
 
// 与仓库 APK 工程匹配的 Android SDK 组件版本（.so 由 SDK 预编译，无需 NDK）。
const char* kAndroidPlatform = "platforms;android-34";
const char* kAndroidBuildTools = "build-tools;34.0.0";
 
// APK 模板的 gradle-wrapper.properties 指定的 Gradle 版本。
const char* kGradleVersion = "8.5";
 
std::string gradleUrl() {
    return std::string("https://services.gradle.org/distributions/gradle-") + kGradleVersion +
           "-bin.zip";
}
 
bool jdkHomeExists(const std::string& home) {
    std::error_code ec;
    return std::filesystem::is_regular_file(
               std::filesystem::path(home) / "bin" / ("java" + exeSuffix()), ec) ||
           std::filesystem::is_regular_file(
               std::filesystem::path(home) / "bin" / ("javac" + exeSuffix()), ec);
}
 
// 下载一个压缩包并用系统 tar 解压（Windows 10+ 自带 bsdtar）。
[[nodiscard]] eve::Result<void> downloadAndExtract(const std::string& url, const std::string& zipPath,
                                                   const std::string& extractDir) {
    if (runShell("curl -fL --retry 3 -o \"" + zipPath + "\" \"" + url + "\"") != 0) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "download failed", url, {}, "cmdline.sdk"));
    }
    std::error_code ec;
    if (!nonEmptyRegularFile(zipPath, ec)) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "download returned an empty or unreadable response", url, {}, "cmdline.sdk"));
    }
    std::filesystem::remove_all(extractDir, ec);
    std::filesystem::create_directories(extractDir, ec);
    if (ec) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create extraction directory: " + ec.message(), extractDir, {}, "cmdline.sdk"));
    }
    if (!extractZip(zipPath, extractDir)) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "downloaded archive is empty, truncated, or unsupported", zipPath, {}, "cmdline.sdk"));
    }
    std::filesystem::remove(zipPath, ec);
    if (ec) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot remove temporary downloaded archive: " + ec.message(), zipPath, {}, "cmdline.sdk"));
    }
    return eve::Result<void>::success();
}
 
// move 失败（跨盘符等）时退化为递归 copy。
bool moveOrCopy(const std::filesystem::path& from, const std::filesystem::path& to) {
    std::error_code ec;
    std::filesystem::remove_all(to, ec);
    std::filesystem::rename(from, to, ec);
    if (!ec) return true;
    ec.clear();
    std::filesystem::copy(from, to,
                          std::filesystem::copy_options::recursive |
                              std::filesystem::copy_options::overwrite_existing,
                          ec);
    return !ec;
}
 
[[nodiscard]] eve::Result<void> installJdk(const std::string& root) {
    const std::string url = getEnv("EVE_JDK17_URL", temurinJdk17Url());
    std::cout << "eve get: downloading JDK 17 (Temurin)...\n";
    const std::string tmp = root + "/.jdk-extract";
    auto              downloaded = downloadAndExtract(url, root + "/jdk17.zip", tmp);
    if (!downloaded.ok()) return eve::Result<void>::failure(downloaded.status());
    std::error_code ec;
    std::filesystem::path jdkDir;
    for (const auto& entry : std::filesystem::directory_iterator(tmp, ec)) {
        if (entry.is_directory()) {
            jdkDir = entry.path();
            break;
        }
    }
    if (ec || jdkDir.empty() || !moveOrCopy(jdkDir, std::filesystem::path(root) / "jdk17")) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "unexpected JDK archive layout", tmp, {}, "cmdline.sdk"));
    }
    std::filesystem::remove_all(tmp, ec);
    return eve::Result<void>::success();
}
 
[[nodiscard]] eve::Result<void> installGradle(const std::string& root) {
    const std::string url = getEnv("EVE_GRADLE_URL", gradleUrl());
    std::cout << "eve get: downloading Gradle " << kGradleVersion << "...\n";
    const std::string tmp = root + "/.gradle-extract";
    auto              downloaded = downloadAndExtract(url, root + "/gradle.zip", tmp);
    if (!downloaded.ok()) return eve::Result<void>::failure(downloaded.status());
    std::error_code ec;
    const auto gradleDir = std::filesystem::path(root) / ("gradle-" + std::string(kGradleVersion));
    if (!moveOrCopy(std::filesystem::path(tmp) / ("gradle-" + std::string(kGradleVersion)),
                    gradleDir)) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "unexpected Gradle archive layout", tmp, {}, "cmdline.sdk"));
    }
    std::filesystem::remove_all(tmp, ec);
    return eve::Result<void>::success();
}
 
bool gradleInstalled(const std::string& gradleHome) {
    std::error_code ec;
    return std::filesystem::is_regular_file(
               std::filesystem::path(gradleHome) / "bin" / "gradle", ec) ||
           std::filesystem::is_regular_file(
               std::filesystem::path(gradleHome) / "bin" / "gradle.bat", ec);
}
 
}  // namespace
 
bool isAndroidSdkInstalled(const std::string& root) {
    std::error_code ec;
    return std::filesystem::is_regular_file(
        std::filesystem::path(root) / "cmdline-tools" / "latest" / "bin" /
            ("sdkmanager" + sdkmanagerSuffix()),
        ec);
}
 
eve::Result<void> installAndroidSdk() {
    // EVEngine 官方 android SDK 优先：预编译 native 库 + APK 模板按当前 eve
    // 版本从 GitHub Release 下载（校验 SHA256）。
    auto eveSdk = installEveSdk(Platform::Android);
    if (!eveSdk.ok()) return eve::Result<void>::failure(eveSdk.status());
 
    const std::string root = androidSdkRoot();
    std::error_code ec;
    std::filesystem::create_directories(root, ec);
    if (ec) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create Android SDK directory: " + ec.message(), root, {}, "cmdline.sdk"));
    }
 
    const std::string sdkManager =
        root + "/cmdline-tools/latest/bin/sdkmanager" + sdkmanagerSuffix();
    if (isAndroidSdkInstalled(root)) {
        std::cout << "eve get: Android SDK already installed at " << root << "\n";
    } else {
        std::cout << "eve get: downloading Android command-line tools...\n";
        const std::string url =
            getEnv("EVE_ANDROID_CMDLINE_TOOLS_URL", androidCmdlineToolsUrl());
        const std::string tmp = root + "/.cmdline-tools-extract";
        auto              downloaded = downloadAndExtract(url, root + "/cmdline-tools.zip", tmp);
        if (!downloaded.ok()) return eve::Result<void>::failure(downloaded.status());
        if (!std::filesystem::is_directory(std::filesystem::path(tmp) / "cmdline-tools", ec)) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::ParseError, "unexpected Android command-line tools archive layout", tmp, {}, "cmdline.sdk"));
        }
        if (!moveOrCopy(std::filesystem::path(tmp) / "cmdline-tools",
                        std::filesystem::path(root) / "cmdline-tools" / "latest")) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "failed to install Android command-line tools", root + "/cmdline-tools/latest", {}, "cmdline.sdk"));
        }
        std::filesystem::remove_all(tmp, ec);
    }
 
    // JDK 17 优先复用 $JAVA_HOME；否则下载 Temurin 17 到 <sdk>/jdk17。
    std::string javaHome = getEnv("JAVA_HOME");
    if (javaHome.empty()) {
        javaHome = (std::filesystem::path(root) / "jdk17").string();
        if (!jdkHomeExists(javaHome)) {
            auto jdk = installJdk(root);
            if (!jdk.ok()) return eve::Result<void>::failure(jdk.status());
        }
    } else if (!jdkHomeExists(javaHome)) {
        std::cerr << "eve get: warning: JAVA_HOME=" << javaHome
                  << " does not contain bin/java; make sure it points at a JDK 17+.\n";
    }
    setEnv("JAVA_HOME", javaHome);
 
    // 接受许可并安装组件（sdkmanager 幂等，可重复执行补齐）。
    const std::string lic = root + "/.eve-licenses.txt";
    {
        std::ofstream f(lic, std::ios::binary | std::ios::trunc);
        if (!f) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot create Android SDK license input", lic, {}, "cmdline.sdk"));
        }
        for (int i = 0; i < 200; ++i) f << "y\n";
        if (!f) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot write Android SDK license input", lic, {}, "cmdline.sdk"));
        }
    }
#if defined(_WIN32)
    // cmd /c strips the first/last quote of a command that starts with one, so
    // batch files with spaces in their path need the `call` prefix.
    const std::string sdkCmd = "call \"" + sdkManager + "\"";
#else
    const std::string sdkCmd = "\"" + sdkManager + "\"";
#endif
    std::cout << "eve get: accepting Android SDK licenses...\n";
    if (runShell(sdkCmd + " --licenses < \"" + lic + "\"") != 0) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "failed to accept Android SDK licenses", sdkManager, {}, "cmdline.sdk"));
    }
    std::cout << "eve get: installing SDK packages (platform-tools, android-34, "
                 "build-tools)...\n";
    const std::string packages = "\"platform-tools\" \"" + std::string(kAndroidPlatform) +
                                 "\" \"" + std::string(kAndroidBuildTools) + "\"";
    if (runShell(sdkCmd + " " + packages) != 0) {
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "failed to install Android SDK packages", sdkManager, {}, "cmdline.sdk"));
    }
    std::filesystem::remove(lic, ec);
 
    // Gradle：APK 模板没有 gradlew.bat，直接用发行版启动器，无需额外工具。
    std::string gradleHome = (std::filesystem::path(root) / ("gradle-" + std::string(kGradleVersion))).string();
    if (!gradleInstalled(gradleHome)) {
        auto gradle = installGradle(root);
        if (!gradle.ok()) return eve::Result<void>::failure(gradle.status());
    }
 
    // 记录环境，供 `eve build android` 在环境变量未设置时使用。
    const std::string eveSdkRoot =
        (std::filesystem::path(eveSdkInstallRoot()) / "android").string();
    {
        std::ofstream f(std::filesystem::path(root) / "eve-android.env",
                        std::ios::binary | std::ios::trunc);
        if (!f) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot write Android SDK environment file", (std::filesystem::path(root) / "eve-android.env").string(), {}, "cmdline.sdk"));
        }
        f << "ANDROID_HOME=" << root << "\n"
          << "ANDROID_SDK_ROOT=" << root << "\n"
          << "JAVA_HOME=" << javaHome << "\n"
          << "GRADLE_HOME=" << gradleHome << "\n"
          << "EVENGINE_SDK=" << eveSdkRoot << "\n";
        if (!f) {
            return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Failed, "cannot finish writing Android SDK environment file", (std::filesystem::path(root) / "eve-android.env").string(), {}, "cmdline.sdk"));
        }
    }
 
    std::cout << "eve get: Android SDK ready at " << root << "\n"
              << "eve get: run `eve build android` to build an APK "
                 "(or `eve build -d android` for a debug APK).\n";
    return eve::Result<void>::success();
}
 
namespace {
 
void copyOne(const std::filesystem::path& from, const std::filesystem::path& to,
             const std::vector<std::string>& skipDirs, bool contentsOnly) {
    std::error_code ec;
    if (!contentsOnly) std::filesystem::create_directories(to, ec);
    std::filesystem::recursive_directory_iterator it(
        from, std::filesystem::directory_options::skip_permission_denied, ec);
    std::filesystem::recursive_directory_iterator end;
    for (; it != end; it.increment(ec)) {
        if (ec) {
            ec.clear();
            continue;
        }
        const auto rel = std::filesystem::relative(it->path(), from, ec).lexically_normal();
        if (ec) continue;
        const std::string relStr = rel.generic_string();
        bool              skip   = false;
        for (const auto& d : skipDirs) {
            if (relStr == d || relStr.rfind(d + "/", 0) == 0) {
                skip = true;
                break;
            }
        }
        if (skip) {
            it.disable_recursion_pending();
            continue;
        }
        // 无论是否 contentsOnly，目标都按相对路径落位（contentsOnly 时 to 就是
        // 目标根目录，rel 相对源根目录）。
        const auto dst = to / rel;
        if (it->is_directory()) {
            std::filesystem::create_directories(dst, ec);
        } else if (it->is_regular_file()) {
            std::filesystem::create_directories(dst.parent_path(), ec);
            std::filesystem::copy_file(it->path(), dst,
                                       std::filesystem::copy_options::overwrite_existing, ec);
        }
    }
}
 
}  // namespace
 
bool copyTree(const std::string& from, const std::string& to,
              const std::vector<std::string>& skipDirs) {
    std::error_code ec;
    if (!std::filesystem::is_directory(from, ec)) return false;
    copyOne(from, to, skipDirs, /*contentsOnly=*/false);
    return true;
}
 
bool copyTreeContents(const std::string& from, const std::string& to) {
    std::error_code ec;
    if (!std::filesystem::is_directory(from, ec)) return false;
    std::filesystem::create_directories(to, ec);
    copyOne(from, to, {}, /*contentsOnly=*/true);
    return true;
}
 
}  // namespace eve::cmd::sdk