Catalog ops & inventory visibility

const base = process.env.EPOCHAL_API_BASE ?? "https://epochalstock.com/api/v1";
const apiKey = process.env.EPOCHAL_API_KEY;

async function probeHealth() {
  const res = await fetch(\`${base}/health\`);
  return { status: res.status, ok: res.status === 200 };
}

async function probeStats() {
  if (!apiKey) throw new Error("Set EPOCHAL_API_KEY");
  const res = await fetch(\`${base}/stats\`, {
    headers: {
      Authorization: \`Bearer ${apiKey}\`,
      Accept: "application/json",
    },
  });
  const headers = {
    limit: res.headers.get("X-RateLimit-Limit"),
    remaining: res.headers.get("X-RateLimit-Remaining"),
    reset: res.headers.get("X-RateLimit-Reset"),
    requestId: res.headers.get("X-Request-ID"),
  };
  if (res.status === 429) {
    return { status: 429, retryAfter: res.headers.get("Retry-After"), headers };
  }
  if (!res.ok) throw new Error(\`stats ${res.status}: ${await res.text()}\`);
  const body = await res.json();
  return {
    status: res.status,
    headers,
    total_images: body.data.total_images,
    total_tags: body.data.total_tags,
    catalog_built_at: body.data.catalog_built_at,
  };
}

// Cache these results in your process; serve ops UI from cache
const health = await probeHealth();
const stats = await probeStats();
console.log({ health, stats });

<?php
declare(strict_types=1);

$base = rtrim(getenv('EPOCHAL_API_BASE') ?: 'https://epochalstock.com/api/v1', '/');
$apiKey = getenv('EPOCHAL_API_KEY');

function probe_health(string $base): array
{
    $ch = curl_init($base . '/health');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 10,
    ]);
    curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    return ['status' => $status, 'ok' => $status === 200];
}

function probe_stats(string $base, string $apiKey): array
{
    $ch = curl_init($base . '/stats');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HEADER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $apiKey,
            'Accept: application/json',
        ],
        CURLOPT_TIMEOUT => 20,
    ]);
    $raw = curl_exec($ch);
    $headerSize = (int) curl_getinfo($ch, CURLINFO_HEADER_SIZE);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $headerBlob = substr((string) $raw, 0, $headerSize);
    $bodyRaw = substr((string) $raw, $headerSize);
    // Parse X-RateLimit-* from $headerBlob for your metrics sink
    if ($status !== 200) {
        throw new RuntimeException('stats failed: ' . $status . ' ' . $bodyRaw);
    }
    $data = json_decode($bodyRaw, true, 512, JSON_THROW_ON_ERROR)['data'];
    return [
        'total_images' => $data['total_images'],
        'total_tags' => $data['total_tags'],
        'catalog_built_at' => $data['catalog_built_at'],
        'raw_headers' => $headerBlob,
    ];
}

$health = probe_health($base);
$stats = $apiKey ? probe_stats($base, $apiKey) : null;
// Persist to cache; ops UI reads cache only

import os
import requests

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


def probe_health() -> dict:
    r = requests.get(f"{base}/health", timeout=10)
    return {"status": r.status_code, "ok": r.status_code == 200}


def probe_stats() -> dict:
    if not api_key:
        raise RuntimeError("Set EPOCHAL_API_KEY")
    r = requests.get(
        f"{base}/stats",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Accept": "application/json",
        },
        timeout=20,
    )
    headers = {
        "limit": r.headers.get("X-RateLimit-Limit"),
        "remaining": r.headers.get("X-RateLimit-Remaining"),
        "reset": r.headers.get("X-RateLimit-Reset"),
        "request_id": r.headers.get("X-Request-ID"),
        "retry_after": r.headers.get("Retry-After"),
    }
    if r.status_code == 429:
        return {"status": 429, "headers": headers}
    r.raise_for_status()
    data = r.json()["data"]
    return {
        "status": r.status_code,
        "headers": headers,
        "total_images": data["total_images"],
        "total_tags": data["total_tags"],
        "catalog_built_at": data["catalog_built_at"],
    }


print(probe_health())
print(probe_stats())

package main

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

func probeHealth(base string) (int, error) {
    client := &http.Client{Timeout: 10 * time.Second}
    res, err := client.Get(base + "/health")
    if err != nil {
        return 0, err
    }
    defer res.Body.Close()
    io.Copy(io.Discard, res.Body)
    return res.StatusCode, nil
}

func probeStats(base, apiKey string) error {
    req, _ := http.NewRequest(http.MethodGet, base+"/stats", nil)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    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()

    fmt.Println("X-RateLimit-Limit", res.Header.Get("X-RateLimit-Limit"))
    fmt.Println("X-RateLimit-Remaining", res.Header.Get("X-RateLimit-Remaining"))
    fmt.Println("X-RateLimit-Reset", res.Header.Get("X-RateLimit-Reset"))
    fmt.Println("X-Request-ID", res.Header.Get("X-Request-ID"))

    body, _ := io.ReadAll(res.Body)
    if res.StatusCode != http.StatusOK {
        return fmt.Errorf("stats %d: %s", res.StatusCode, body)
    }
    var payload struct {
        Data struct {
            TotalImages    int    `json:"total_images"`
            TotalTags      int    `json:"total_tags"`
            CatalogBuiltAt string `json:"catalog_built_at"`
        } `json:"data"`
    }
    if err := json.Unmarshal(body, &payload); err != nil {
        return err
    }
    fmt.Println(payload.Data.TotalImages, payload.Data.TotalTags, payload.Data.CatalogBuiltAt)
    return nil
}

func main() {
    base := os.Getenv("EPOCHAL_API_BASE")
    if base == "" {
        base = "https://epochalstock.com/api/v1"
    }
    if status, err := probeHealth(base); err != nil {
        panic(err)
    } else {
        fmt.Println("health", status)
    }
    if err := probeStats(base, os.Getenv("EPOCHAL_API_KEY")); err != nil {
        panic(err)
    }
}

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

var baseUrl = (Environment.GetEnvironmentVariable("EPOCHAL_API_BASE")
    ?? "https://epochalstock.com/api/v1").TrimEnd('/');
var apiKey = Environment.GetEnvironmentVariable("EPOCHAL_API_KEY");

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(20) };

// Health — no API key
using (var healthRes = await client.GetAsync(baseUrl + "/health"))
{
    Console.WriteLine("health " + (int)healthRes.StatusCode);
}

// Stats — Bearer required
if (string.IsNullOrEmpty(apiKey)) throw new InvalidOperationException("Set EPOCHAL_API_KEY");
using var statsReq = new HttpRequestMessage(HttpMethod.Get, baseUrl + "/stats");
statsReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
statsReq.Headers.Accept.ParseAdd("application/json");

using var statsRes = await client.SendAsync(statsReq);
Console.WriteLine("X-RateLimit-Remaining: " +
    (statsRes.Headers.TryGetValues("X-RateLimit-Remaining", out var rem)
        ? string.Join(",", rem) : "(none)"));
statsRes.EnsureSuccessStatusCode();

using var doc = JsonDocument.Parse(await statsRes.Content.ReadAsStringAsync());
var data = doc.RootElement.GetProperty("data");
Console.WriteLine(data.GetProperty("total_images"));
Console.WriteLine(data.GetProperty("total_tags"));
Console.WriteLine(data.GetProperty("catalog_built_at"));

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

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

# Health — no API key
health_uri = URI("#{base}/health")
health = Net::HTTP.start(health_uri.host, health_uri.port, use_ssl: true) do |http|
  http.get(health_uri.request_uri)
end
puts "health #{health.code}"

# Stats — Bearer required
raise "Set EPOCHAL_API_KEY" if api_key.nil? || api_key.empty?
stats_uri = URI("#{base}/stats")
req = Net::HTTP::Get.new(stats_uri)
req["Authorization"] = "Bearer #{api_key}"
req["Accept"] = "application/json"

stats = Net::HTTP.start(stats_uri.host, stats_uri.port, use_ssl: true) do |http|
  http.request(req)
end
puts "X-RateLimit-Remaining: #{stats["X-RateLimit-Remaining"]}"
raise "stats failed: #{stats.code}" unless stats.code.to_i == 200
data = JSON.parse(stats.body).fetch("data")
puts [data["total_images"], data["total_tags"], data["catalog_built_at"]].join(" ")