Safe original export pipeline

import { writeFile } from "node:fs/promises";

const base = process.env.EPOCHAL_API_BASE ?? "https://epochalstock.com/api/v1";
const apiKey = process.env.EPOCHAL_API_KEY;
if (!apiKey) throw new Error("Set EPOCHAL_API_KEY");

const ids = ["es_001_example", "es_002_example"];

async function sleep(ms) {
  return new Promise((r) => setTimeout(r, ms));
}

async function exportOne(imageId, attempt = 1) {
  const mint = await fetch(`${base}/downloads`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
      Accept: "application/json",
    },
    body: JSON.stringify({ image_id: imageId }),
  });

  if (mint.status === 409) {
    // download_already_active — another original is transferring
    if (attempt >= 8) throw new Error("lease busy too long");
    const wait = Math.min(30_000, 500 * 2 ** (attempt - 1)) + Math.random() * 250;
    await sleep(wait);
    return exportOne(imageId, attempt + 1);
  }

  if (mint.status === 429) {
    const retryAfter = Number(mint.headers.get("Retry-After") || "5");
    await sleep(retryAfter * 1000);
    return exportOne(imageId, attempt + 1);
  }

  if (!mint.ok) {
    throw new Error(`mint ${mint.status}: ${await mint.text()}`);
  }

  const { data } = await mint.json();
  const fileRes = await fetch(data.download_url); // no Authorization
  if (!fileRes.ok) throw new Error(`download ${fileRes.status}`);
  await writeFile(`${imageId}.bin`, Buffer.from(await fileRes.arrayBuffer()));
}

// Serial only — do not Promise.all exportOne calls on one account
for (const id of ids) {
  await exportOne(id);
}

<?php
declare(strict_types=1);

$base = getenv('EPOCHAL_API_BASE') ?: 'https://epochalstock.com/api/v1';
$apiKey = getenv('EPOCHAL_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set EPOCHAL_API_KEY');
}

/**
 * @return void
 */
function export_one(string $base, string $apiKey, string $imageId, int $attempt = 1): void
{
    $ch = curl_init(rtrim($base, '/') . '/downloads');
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json',
            'Accept: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode(['image_id' => $imageId], JSON_THROW_ON_ERROR),
        CURLOPT_TIMEOUT => 20,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($status === 409) {
        // download_already_active
        if ($attempt >= 8) {
            throw new RuntimeException('lease busy too long');
        }
        usleep((int) ((500 * (2 ** ($attempt - 1))) + random_int(0, 250)) * 1000);
        export_one($base, $apiKey, $imageId, $attempt + 1);
        return;
    }
    if ($status === 429) {
        sleep(5);
        export_one($base, $apiKey, $imageId, $attempt + 1);
        return;
    }
    if ($status !== 201) {
        throw new RuntimeException('mint failed: ' . (string) $raw);
    }

    $downloadUrl = json_decode((string) $raw, true, 512, JSON_THROW_ON_ERROR)['data']['download_url'];

    $ch = curl_init($downloadUrl);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_FOLLOWLOCATION => true,
        CURLOPT_TIMEOUT => 120,
    ]);
    $bytes = curl_exec($ch);
    $dlStatus = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    if ($dlStatus !== 200) {
        throw new RuntimeException('download failed: ' . $dlStatus);
    }
    file_put_contents($imageId . '.bin', $bytes);
}

// Serial loop — never fan out concurrent originals for one account
foreach (['es_001_example', 'es_002_example'] as $id) {
    export_one($base, $apiKey, $id);
}

import os
import random
import time
import requests

base = os.environ.get("EPOCHAL_API_BASE", "https://epochalstock.com/api/v1").rstrip("/")
api_key = os.environ["EPOCHAL_API_KEY"]
ids = ["es_001_example", "es_002_example"]


def export_one(image_id: str, attempt: int = 1) -> None:
    mint = requests.post(
        f"{base}/downloads",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
            "Accept": "application/json",
        },
        json={"image_id": image_id},
        timeout=20,
    )

    if mint.status_code == 409:
        # download_already_active — serialize and retry
        if attempt >= 8:
            raise RuntimeError("lease busy too long")
        time.sleep(min(30, 0.5 * (2 ** (attempt - 1))) + random.random() * 0.25)
        return export_one(image_id, attempt + 1)

    if mint.status_code == 429:
        retry_after = int(mint.headers.get("Retry-After", "5"))
        time.sleep(retry_after)
        return export_one(image_id, attempt + 1)

    mint.raise_for_status()
    download_url = mint.json()["data"]["download_url"]

    # Binary GET — no API key
    with requests.get(download_url, stream=True, timeout=120) as r:
        r.raise_for_status()
        with open(f"{image_id}.bin", "wb") as f:
            for chunk in r.iter_content(chunk_size=256 * 1024):
                if chunk:
                    f.write(chunk)


# Serial only
for image_id in ids:
    export_one(image_id)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "math"
    "math/rand"
    "net/http"
    "os"
    "time"
)

func exportOne(base, apiKey, imageID string, attempt int) error {
    body, _ := json.Marshal(map[string]string{"image_id": imageID})
    req, _ := http.NewRequest(http.MethodPost, base+"/downloads", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")

    client := &http.Client{Timeout: 20 * time.Second}
    res, err := client.Do(req)
    if err != nil {
        return err
    }
    defer res.Body.Close()

    if res.StatusCode == http.StatusConflict { // 409 download_already_active
        if attempt >= 8 {
            return fmt.Errorf("lease busy too long")
        }
        wait := time.Duration(math.Min(30, 0.5*math.Pow(2, float64(attempt-1)))*1000) * time.Millisecond
        time.Sleep(wait + time.Duration(rand.Intn(250))*time.Millisecond)
        return exportOne(base, apiKey, imageID, attempt+1)
    }
    if res.StatusCode == http.StatusTooManyRequests {
        time.Sleep(5 * time.Second)
        return exportOne(base, apiKey, imageID, attempt+1)
    }
    if res.StatusCode != http.StatusCreated {
        b, _ := io.ReadAll(res.Body)
        return fmt.Errorf("mint %d: %s", res.StatusCode, b)
    }

    var payload struct {
        Data struct {
            DownloadURL string `json:"download_url"`
        } `json:"data"`
    }
    if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
        return err
    }

    dlClient := &http.Client{Timeout: 120 * time.Second}
    dl, err := dlClient.Get(payload.Data.DownloadURL) // no API key
    if err != nil {
        return err
    }
    defer dl.Body.Close()
    out, err := os.Create(imageID + ".bin")
    if err != nil {
        return err
    }
    defer out.Close()
    _, err = io.Copy(out, dl.Body)
    return err
}

func main() {
    base := os.Getenv("EPOCHAL_API_BASE")
    if base == "" {
        base = "https://epochalstock.com/api/v1"
    }
    apiKey := os.Getenv("EPOCHAL_API_KEY")
    for _, id := range []string{"es_001_example", "es_002_example"} {
        if err := exportOne(base, apiKey, id, 1); err != nil {
            panic(err)
        }
    }
}

using System.Net;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var baseUrl = Environment.GetEnvironmentVariable("EPOCHAL_API_BASE")
    ?? "https://epochalstock.com/api/v1";
var apiKey = Environment.GetEnvironmentVariable("EPOCHAL_API_KEY")
    ?? throw new InvalidOperationException("Set EPOCHAL_API_KEY");

async Task ExportOneAsync(string imageId, int attempt = 1)
{
    using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(20) };
    using var mintReq = new HttpRequestMessage(
        HttpMethod.Post,
        baseUrl.TrimEnd('/') + "/downloads");
    mintReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
    mintReq.Headers.Accept.ParseAdd("application/json");
    mintReq.Content = new StringContent(
        JsonSerializer.Serialize(new { image_id = imageId }),
        Encoding.UTF8,
        "application/json");

    using var mintRes = await client.SendAsync(mintReq);
    if (mintRes.StatusCode == HttpStatusCode.Conflict) // 409 download_already_active
    {
        if (attempt >= 8) throw new InvalidOperationException("lease busy too long");
        var ms = Math.Min(30_000, 500 * (int)Math.Pow(2, attempt - 1)) + Random.Shared.Next(0, 250);
        await Task.Delay(ms);
        await ExportOneAsync(imageId, attempt + 1);
        return;
    }
    if ((int)mintRes.StatusCode == 429)
    {
        await Task.Delay(TimeSpan.FromSeconds(5));
        await ExportOneAsync(imageId, attempt + 1);
        return;
    }
    mintRes.EnsureSuccessStatusCode();

    using var doc = JsonDocument.Parse(await mintRes.Content.ReadAsStringAsync());
    var downloadUrl = doc.RootElement.GetProperty("data").GetProperty("download_url").GetString()!;

    using var dlClient = new HttpClient { Timeout = TimeSpan.FromMinutes(2) };
    using var fileRes = await dlClient.GetAsync(downloadUrl); // no API key
    fileRes.EnsureSuccessStatusCode();
    await using var fs = File.Create(imageId + ".bin");
    await fileRes.Content.CopyToAsync(fs);
}

// Serial only
foreach (var id in new[] { "es_001_example", "es_002_example" })
{
    await ExportOneAsync(id);
}

require "json"
require "net/http"
require "uri"

base = ENV.fetch("EPOCHAL_API_BASE", "https://epochalstock.com/api/v1").sub(%r{/+\z}, "")
api_key = ENV.fetch("EPOCHAL_API_KEY")

def export_one(base, api_key, image_id, attempt = 1)
  uri = URI("#{base}/downloads")
  req = Net::HTTP::Post.new(uri)
  req["Authorization"] = "Bearer #{api_key}"
  req["Content-Type"] = "application/json"
  req["Accept"] = "application/json"
  req.body = { image_id: image_id }.to_json

  mint = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }

  if mint.code.to_i == 409
    # download_already_active
    raise "lease busy too long" if attempt >= 8
    sleep([30, 0.5 * (2 ** (attempt - 1))].min + rand * 0.25)
    return export_one(base, api_key, image_id, attempt + 1)
  end
  if mint.code.to_i == 429
    sleep 5
    return export_one(base, api_key, image_id, attempt + 1)
  end
  raise "mint failed: #{mint.code}" unless mint.code.to_i == 201

  download_url = JSON.parse(mint.body).dig("data", "download_url")
  dl_uri = URI(download_url)
  Net::HTTP.start(dl_uri.host, dl_uri.port, use_ssl: true) do |http|
    resp = http.get(dl_uri.request_uri) # no API key
    raise "download failed: #{resp.code}" unless resp.code.to_i == 200
    File.binwrite("#{image_id}.bin", resp.body)
  end
end

# Serial only
%w[es_001_example es_002_example].each { |id| export_one(base, api_key, id) }