Method StartImageDownload

src/daemon/cloud_tunnel.cpp:1384–1575

}

nlohmann::json CloudTunnel::StartImageDownload(const nlohmann::json& payload) {
    const auto image = ImageFromJson(payload.value("image", nlohmann::json::object()));
    if (image.id.empty() || image.files.empty()) return Error("image_invalid", "invalid image metadata");

    // Hard guard against host/image platform mismatch. Without this, a buggy
    // or stale console can hand us an x86_64 rootfs on an arm64 host, and we
    // happily download ~1.6 GB only to fail at boot with "invalid ARM64 Image
    // magic". Platform identity comes from the image manifest (authoritative)
    // and is matched against the host's compiled-in arch.
    const std::string host_platform = image_source::HostPlatform();
    const std::string image_platform = image_source::NormalizePlatform(image.platform);
    if (image_platform != host_platform) {
        return Error("image_arch_mismatch",
                     "image platform '" + image_platform +
                         "' does not match host platform '" + host_platform + "'");
    }

    const std::string images_dir = ImagesDir(config_);
    if (image_source::IsImageCached(images_dir, image)) {
        return {{"job_id", ""}, {"cache_id", image.CacheId()}, {"status", "done"}};
    }

    const std::string job_id = GenerateUuid();
    {
        std::lock_guard<std::mutex> lock(download_mu_);
        for (const auto& [id, job] : download_jobs_) {
            if (job.cache_id == image.CacheId() && (job.status == "running" || job.status == "pending")) {
                return {{"job_id", id}, {"cache_id", job.cache_id}, {"status", job.status}};
            }
        }
        DownloadJob job;
        job.job_id = job_id;
        job.cache_id = image.CacheId();
        job.image_name = image.display_name;
        job.status = "running";
        job.total_bytes = image.TotalSize();
        job.started_at = UnixNow();
        job.updated_at = job.started_at;
        download_jobs_[job_id] = job;
    }

    std::thread([this, image, job_id, images_dir]() {
        pthread_setname_np(pthread_self(), "img-download");
        const std::string cache_dir = image_source::ImageCacheDir(images_dir, image);
        const auto started = std::chrono::steady_clock::now();
        // Browser-side progress is rate-limited to ~2Hz to avoid flooding the
        // WS with envelope traffic when curl reports tiny deltas faster than
        // the user can perceive.
        auto last_progress_push = std::chrono::steady_clock::now() -
                                  std::chrono::seconds(1);
        std::error_code ec;
        std::filesystem::create_directories(cache_dir, ec);
        bool ok = !ec;
        std::string error = ec ? ec.message() : "";
        uint64_t done = 0;
        for (const auto& file : image.files) {
            if (!ok) break;
            const auto dest = std::filesystem::path(cache_dir) / file.name;