Display usage & stats in your panel

curl -X POST https://api.swarmz.net/functions/v1/platform-usage \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{ "tenant_id": "<workspace-uuid>", "period": "current_month" }'

async function fetchTenantStats(tenantId: string) {
  const res = await fetch('https://api.swarmz.net/functions/v1/platform-usage', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.SWARMZ_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ tenant_id: tenantId, period: 'current_month' }),
  });
  if (!res.ok) throw new Error(`platform-usage ${res.status}`);
  return res.json(); // { ok, usage, balances }
}

import os
import requests

def fetch_tenant_stats(tenant_id: str) -> dict:
    res = requests.post(
        "https://api.swarmz.net/functions/v1/platform-usage",
        headers={"Authorization": f"Bearer {os.environ['SWARMZ_API_KEY']}"},
        json={"tenant_id": tenant_id, "period": "current_month"},
    )
    res.raise_for_status()
    return res.json()  # { ok, usage, balances }

function selectTenant(payload: any, tenantId: string) {
  const usageRow =
    payload.usage?.by_workspace?.find((w: any) => w.workspace_id === tenantId) ?? {
      credits_used: 0, usd_credits: 0, cloud_usd: 0,
    };

  // balances can be null on a read failure — guard it.
  const balanceRow =
    payload.balances?.by_workspace?.find((w: any) => w.workspace_id === tenantId) ?? null;

  return { usageRow, balanceRow, period: payload.usage.period };
}

def select_tenant(payload: dict, tenant_id: str):
    usage_row = next(
        (w for w in payload["usage"]["by_workspace"] if w["workspace_id"] == tenant_id),
        {"credits_used": 0, "usd_credits": 0, "cloud_usd": 0},
    )
    balances = payload.get("balances")
    balance_row = None
    if balances:
        balance_row = next(
            (w for w in balances["by_workspace"] if w["workspace_id"] == tenant_id),
            None,
        )
    return usage_row, balance_row, payload["usage"]["period"]

// custom-domains on/off is NOT in platform-usage; pass what you set via
// entitlements (or platform-plans) so the panel can show "not available".
function buildPanel(payload: any, tenantId: string, opts: { customDomainsEnabled: boolean }) {
  const { usageRow, balanceRow, period } = selectTenant(payload, tenantId);
  const caps = balanceRow?.caps ?? {};
  const fmtUsd = (n: number) => `$${(n ?? 0).toFixed(2)}`;
  const orInf = (n: number | null) => (n == null ? '∞' : String(n));

  return {
    period: period.label, // 'current_month' | 'last_month' | 'ytd'

    pools: {
      freeDaily: {
        allowance: caps.credits_per_day,          // null ⇒ unlimited
        display: caps.credits_per_day == null ? '∞' : `${caps.credits_per_day}/day`,
        monthlyCeiling: caps.monthly_credit_cap,  // optional "up to N/month"
        resets: 'daily 00:00 UTC',
      },
      monthly: {
        remaining: balanceRow?.included_remaining ?? null,
        size: balanceRow?.included_credits ?? 0,   // 0 ⇒ "not included on this plan"
        rolledOver: balanceRow?.rollover_remaining ?? 0,
        rolloverMonths: caps.rollover_months ?? 0,
        rolloverExpiry: balanceRow?.rollover_expiry ?? null,
      },
      topup: {
        available: balanceRow?.topup_available ?? 0,
        purchasedTotal: balanceRow?.purchased_total ?? 0,
        used: balanceRow?.purchased_consumed ?? 0,
      },
    },

    plan: {
      publishedLimit: orInf(caps.max_published_projects),
      projectsLimit: orInf(caps.max_projects),
      domainsLimit: orInf(caps.max_custom_domains),
      customDomainsEnabled: opts.customDomainsEnabled,
      cloudBudgetCap: caps.cloud_budget_cap, // null ⇒ unlimited
    },

    spend: {
      creditsUsed: usageRow.credits_used,
      aiSpend: fmtUsd(usageRow.usd_credits),
      cloudSpend: fmtUsd(usageRow.cloud_usd),
    },

    // true when balances came back; false ⇒ fall back to your stored plan caps
    balancesAvailable: payload.balances != null,
  };
}

def build_panel(payload: dict, tenant_id: str, custom_domains_enabled: bool) -> dict:
    usage_row, balance_row, period = select_tenant(payload, tenant_id)
    caps = (balance_row or {}).get("caps", {})
    fmt_usd = lambda n: f"${(n or 0):.2f}"
    or_inf = lambda n: "∞" if n is None else str(n)

    return {
        "period": period["label"],  # current_month | last_month | ytd
        "pools": {
            "free_daily": {
                "allowance": caps.get("credits_per_day"),  # None ⇒ unlimited
                "display": "∞" if caps.get("credits_per_day") is None
                           else f"{caps['credits_per_day']}/day",
                "monthly_ceiling": caps.get("monthly_credit_cap"),
                "resets": "daily 00:00 UTC",
            },
            "monthly": {
                "remaining": (balance_row or {}).get("included_remaining"),
                "size": (balance_row or {}).get("included_credits", 0),  # 0 ⇒ not on plan
                "rolled_over": (balance_row or {}).get("rollover_remaining", 0),
                "rollover_months": caps.get("rollover_months", 0),
                "rollover_expiry": (balance_row or {}).get("rollover_expiry"),
            },
            "topup": {
                "available": (balance_row or {}).get("topup_available", 0),
                "purchased_total": (balance_row or {}).get("purchased_total", 0),
                "used": (balance_row or {}).get("purchased_consumed", 0),
            },
        },
        "plan": {
            "published_limit": or_inf(caps.get("max_published_projects")),
            "projects_limit": or_inf(caps.get("max_projects")),
            "domains_limit": or_inf(caps.get("max_custom_domains")),
            "custom_domains_enabled": custom_domains_enabled,
            "cloud_budget_cap": caps.get("cloud_budget_cap"),  # None ⇒ unlimited
        },
        "spend": {
            "credits_used": usage_row["credits_used"],
            "ai_spend": fmt_usd(usage_row["usd_credits"]),
            "cloud_spend": fmt_usd(usage_row["cloud_usd"]),
        },
        "balances_available": payload.get("balances") is not None,
    }