@crievo/omni 0.0.0-stage → 0.1.0

package/tools/usage.py

@@ -0,0 +1,628 @@
+#!/usr/bin/env python3
+"""Usage of the paid voices: what each generation spent and what is left on each platform.
+
+    usage.py                    summary of what is recorded (does not call the platforms)
+    usage.py --live             asks the platforms now and summarizes
+    usage.py summary --json     the same as data (what the studio reads)
+    usage.py events [--n 30]    last records of .usage/events.jsonl
+    usage.py keys               which keys are filled (without showing values)
+
+Two sources, always side by side:
+
+  record     each line generated by omnivideo (provider, video, chars, bytes),
+             written by `omnivideo.py voice` to .usage/events.jsonl. It is an
+             estimate: it does not see what another app spent on the same account.
+  platform   what the platform itself says, read at the end of each `voice` run
+             and when --live is asked.
+
+Fish Audio  GET /wallet/self/api-credit with the normal key (FISH_API_KEY): the
+            prepaid API balance and the total topped up so far. The cycle's
+            spend is the difference of (topped up − balance) between two reads,
+            which does not get mixed up with a top-up. The plan's 8k free credits
+            belong to the app, not the API. Lines from the `-free` model
+            (voice.fish.model) are not charged: the estimated cost counts only
+            the paid ones (fallback_model).
+Cartesia    GET /usage/credits only accepts an ADMIN key (sk_car_admin_…, in
+            CARTESIA_ADMIN_API_KEY) and returns only what was used per window,
+            never the balance, and the API does not tell the plan. The quota comes
+            from the config (`usage.cartesia`: `plan` + `monthly_quota`, in
+            Configurações → Provedores de voz): Free 20k, Pro 100k, Startup 1.25M,
+            Scale 8M per month. What is left is the quota minus what was used;
+            `cycle_day` is the plan's renewal day (the API slices by UTC day).
+            Without the admin key, the usage is the record's estimate.
+
+Keys: environment or `.env` at the omnivideo root (outside git), as in voice.py.
+Recording usage never takes voice generation down: every failure here becomes a warning.
+"""
+
+import argparse
+import json
+import os
+import ssl
+import sys
+import threading
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+import voice
+from omni_paths import DATA_ROOT as ROOT
+
+DIR = Path(os.environ.get("OMNIVIDEO_USAGE_DIR") or ROOT / ".usage")  # the override is for tests
+EVENTS_FILE = DIR / "events.jsonl"
+CFG = voice.CFG
+UTC = timezone.utc
+
+DEFAULTS = {
+    "fish": {"usd_per_million_bytes": 15.0},
+    "cartesia": {
+        "plan": "free",
+        "monthly_quota": 20000,
+        "credits_per_char": 1,
+        "admin_key_env": "CARTESIA_ADMIN_API_KEY",
+        "cycle_day": 1,
+    },
+}
+
+# credits per month of each Cartesia plan (cartesia.ai/pricing); "other" uses the config's monthly_quota
+CARTESIA_PLANS = {
+    "free": ("Free", 20_000),
+    "pro": ("Pro", 100_000),
+    "startup": ("Startup", 1_250_000),
+    "scale": ("Scale", 8_000_000),
+}
+
+
+def cfg():
+    c = CFG.get("usage") or {}
+    return {k: {**DEFAULTS[k], **(c.get(k) or {})} for k in DEFAULTS}
+
+
+class Unavailable(Exception):
+    pass
+
+
+# --- time --------------------------------------------------------------------
+
+
+def now():
+    return datetime.now(UTC)
+
+
+def iso(dt):
+    return dt.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def cycle(ref, day):
+    """Start and end (UTC) of the monthly cycle containing `ref`. Cartesia slices by UTC day."""
+    day = min(max(int(day), 1), 28)
+    y, m = ref.year, ref.month
+    if ref.day < day:
+        y, m = (y - 1, 12) if m == 1 else (y, m - 1)
+    start = datetime(y, m, day, tzinfo=UTC)
+    y2, m2 = (y + 1, 1) if m == 12 else (y, m + 1)
+    return start, datetime(y2, m2, day, tzinfo=UTC)
+
+
+# --- record ------------------------------------------------------------------
+
+
+def record(event):
+    DIR.mkdir(exist_ok=True)
+    row = json.dumps({"at": iso(now()), **event}, ensure_ascii=False)
+    with open(EVENTS_FILE, "a", encoding="utf-8") as f:
+        f.write(row + "\n")
+
+
+def events():
+    out = []
+    try:
+        with open(EVENTS_FILE, encoding="utf-8") as f:
+            for row in f:
+                try:
+                    out.append(json.loads(row))
+                except ValueError:
+                    continue
+    except FileNotFoundError:
+        pass
+    return out
+
+
+def warn(msg):
+    print(f"uso: {msg}", file=sys.stderr)
+
+
+# --- platforms ---------------------------------------------------------------
+
+
+def _get(url, headers, params=None, timeout=15):
+    if params:
+        url += "?" + urllib.parse.urlencode(params)
+    req = urllib.request.Request(url, headers={"User-Agent": "omnivideo-usage/1", **headers})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl()) as r:
+            return r.status, json.loads(r.read().decode() or "{}")
+    except urllib.error.HTTPError as e:
+        body = e.read().decode(errors="replace")[:300].replace("\n", " ")
+        return e.code, {"error": body}
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError) as e:
+        raise Unavailable(str(e))
+
+
+def _ssl():
+    """VoiceStudio's Python does not ship the root certificates for urllib; `requests`
+    (which generates the voice) uses certifi, and so does this."""
+    try:
+        import certifi
+
+        return ssl.create_default_context(cafile=certifi.where())
+    except ImportError:
+        return ssl.create_default_context()
+
+
+def _num(v):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def fish_key():
+    return voice._env().get(CFG["voice"]["fish"]["key_env"])
+
+
+def cartesia_key():
+    return voice._env().get(CFG["voice"]["cartesia"]["key_env"])
+
+
+def cartesia_admin_key():
+    return voice._env().get(cfg()["cartesia"]["admin_key_env"])
+
+
+def fish_balance(key):
+    status, j = _get("https://api.fish.audio/wallet/self/api-credit", {"Authorization": f"Bearer {key}"})
+    if status != 200:
+        raise Unavailable(f"Fish Audio respondeu {status}: {j.get('error') or j}")
+    return {
+        "credit": _num(j.get("credit")),
+        "cumulative_top_up": _num(j.get("cumulative_top_up")),
+        "has_free_credit": j.get("has_free_credit"),
+    }
+
+
+def cartesia_used(admin, start, end):
+    status, j = _get(
+        "https://api.cartesia.ai/usage/credits",
+        {"Authorization": f"Bearer {admin}", "Cartesia-Version": CFG["voice"]["cartesia"]["api_version"]},
+        {"start_ts": iso(start), "end_ts": iso(end), "interval": "day"},
+    )
+    if status in (401, 403):
+        raise Unavailable(
+            f"Cartesia recusou a chave admin ({status}): precisa ser sk_car_admin_…, não a chave de geração"
+        )
+    if status != 200:
+        raise Unavailable(f"Cartesia respondeu {status}: {j.get('error') or j}")
+    return sum(int(b.get("credits") or 0) for b in j.get("data", []))
+
+
+# --- `voice` hook ------------------------------------------------------------
+
+
+class Run:
+    """One run of `omnivideo.py voice`: what was generated and the balance reads."""
+
+    def __init__(self, video):
+        self.id = uuid.uuid4().hex[:8]
+        self.video = video
+        self.used = set()
+        # the lines of a run are generated in parallel: one writer at a time in the log
+        self._lock = threading.Lock()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        # reads the balance even when generation was interrupted: what was spent was spent
+        try:
+            self.after()
+        except Exception as exc:  # recording usage never takes the voice down
+            warn(f"leitura de saldo falhou: {exc}")
+        return False
+
+    def _record(self, ev):
+        try:
+            with self._lock:
+                record({"run": self.id, "video": self.video, **ev})
+        except OSError as exc:
+            warn(f"não consegui gravar o registro: {exc}")
+
+    def before(self, provider):
+        """Fish balance before generating: the difference to the one after is this run's cost."""
+        if provider != "fish" or not fish_key():
+            return
+        try:
+            self._record({"t": "balance", "provider": "fish", "moment": "before", **fish_balance(fish_key())})
+        except Unavailable as exc:
+            warn(f"saldo da Fish indisponível: {exc}")
+
+    def line(self, provider, line, audio_s, fallback=False, model=None):
+        self.used.add(provider)
+        text = line.get("text", "")
+        ev = {
+            "t": "line",
+            "provider": provider,
+            "line": line.get("id"),
+            "chars": len(text),
+            "bytes": len(text.encode("utf-8")),
+            "audio_s": round(float(audio_s), 3),
+            "fallback": fallback,
+        }
+        if model:
+            ev["model"] = model
+        self._record(ev)
+
+    def failure(self, provider, line_id, reason):
+        self._record({"t": "failure", "provider": provider, "line": line_id, "reason": str(reason)[:200]})
+
+    def after(self):
+        """Reads the platforms used, once per run, at the end of generation."""
+        if "fish" in self.used and fish_key():
+            try:
+                s = fish_balance(fish_key())
+                self._record({"t": "balance", "provider": "fish", "moment": "after", **s})
+            except Unavailable as exc:
+                warn(f"saldo da Fish indisponível: {exc}")
+        if "cartesia" in self.used:
+            if cartesia_admin_key():
+                _cartesia_cycle(self._record, "after")
+            else:
+                warn("sem CARTESIA_ADMIN_API_KEY: o consumo da Cartesia vai como estimativa (caracteres gerados aqui)")
+
+
+def _cartesia_cycle(record_fn, moment):
+    start, end = cycle(now(), cfg()["cartesia"]["cycle_day"])
+    try:
+        used = cartesia_used(cartesia_admin_key(), start, end)
+    except Unavailable as exc:
+        warn(f"consumo da Cartesia indisponível: {exc}")
+        return None
+    record_fn(
+        {"t": "cycle", "provider": "cartesia", "moment": moment, "used": used, "start": iso(start), "end": iso(end)}
+    )
+    return used
+
+
+def refresh():
+    """Asks the platforms now. Returns the errors, as text, for the screen to show."""
+    errors = []
+    run = Run(None)
+    if fish_key():
+        try:
+            run._record({"t": "balance", "provider": "fish", "moment": "query", **fish_balance(fish_key())})
+        except Unavailable as exc:
+            errors.append(f"Fish Audio: {exc}")
+    else:
+        errors.append(f"Fish Audio: sem {CFG['voice']['fish']['key_env']}")
+    if cartesia_admin_key():
+        start, end = cycle(now(), cfg()["cartesia"]["cycle_day"])
+        try:
+            used = cartesia_used(cartesia_admin_key(), start, end)
+            run._record(
+                {
+                    "t": "cycle",
+                    "provider": "cartesia",
+                    "moment": "query",
+                    "used": used,
+                    "start": iso(start),
+                    "end": iso(end),
+                }
+            )
+        except Unavailable as exc:
+            errors.append(f"Cartesia: {exc}")
+    else:
+        errors.append(f"Cartesia: sem {cfg()['cartesia']['admin_key_env']} (chave admin); o consumo é estimado")
+    return errors
+
+
+# --- summary -----------------------------------------------------------------
+
+
+def _sum(evs, field):
+    return sum(e.get(field) or 0 for e in evs)
+
+
+def _paid(e):
+    """A Fish line charged to the balance. A record without a model predates the free one: paid."""
+    return e.get("provider") == "fish" and not voice.is_free(e.get("model"))
+
+
+def _fish_spend(snaps, start):
+    """API spend (topped up − balance) in the cycle, between the last read before it
+    (or the first inside it) and the most recent. None with a single read."""
+    valid = [s for s in snaps if s.get("credit") is not None and s.get("cumulative_top_up") is not None]
+    if len(valid) < 2:
+        return None, None
+    before = [s for s in valid if s["at"] < iso(start)]
+    ref = before[-1] if before else valid[0]
+    last = valid[-1]
+    if ref is last:
+        return None, None
+    spend = (last["cumulative_top_up"] - last["credit"]) - (ref["cumulative_top_up"] - ref["credit"])
+    return round(max(spend, 0.0), 6), ref["at"]
+
+
+def summary(live=False):
+    c = cfg()
+    errors = refresh() if live else []
+    start, end = cycle(now(), c["cartesia"]["cycle_day"])
+    evs = events()
+    in_cycle = [e for e in evs if e.get("at", "") >= iso(start)]
+    lines = [e for e in in_cycle if e.get("t") == "line"]
+
+    # --- Fish
+    f_lines = [e for e in lines if e["provider"] == "fish"]
+    f_paid = [e for e in f_lines if _paid(e)]
+    f_bytes = _sum(f_lines, "bytes")
+    f_bytes_paid = _sum(f_paid, "bytes")
+    fcfg = CFG["voice"]["fish"]
+    snaps = [e for e in evs if e.get("t") == "balance" and e.get("provider") == "fish"]
+    last = snaps[-1] if snaps else None
+    spend, since = _fish_spend(snaps, start)
+    price = c["fish"]["usd_per_million_bytes"]
+    fish = {
+        "name": "Fish Audio",
+        "key": bool(fish_key()),
+        "voice_id": fcfg.get("voice_id") or None,
+        "model": fcfg["model"],
+        "fallback_model": fcfg.get("fallback_model"),
+        "balance": {
+            "credit": last and last.get("credit"),
+            "cumulative_top_up": last and last.get("cumulative_top_up"),
+            "at": last and last["at"],
+        },
+        "cycle": {
+            "lines": len(f_lines),
+            "lines_free": len(f_lines) - len(f_paid),
+            "chars": _sum(f_lines, "chars"),
+            "bytes": f_bytes,
+            "bytes_paid": f_bytes_paid,
+            "estimated_usd": round(f_bytes_paid * price / 1e6, 6),
+            "platform": spend,
+            "platform_since": since,
+        },
+        "price_usd_per_million_bytes": price,
+    }
+
+    # --- Cartesia
+    cc = c["cartesia"]
+    c_lines = [e for e in lines if e["provider"] == "cartesia"]
+    c_chars = _sum(c_lines, "chars")
+    estimated = int(round(c_chars * cc["credits_per_char"]))
+    reads = [
+        e for e in evs if e.get("t") == "cycle" and e.get("provider") == "cartesia" and e.get("start") == iso(start)
+    ]
+    read = reads[-1] if reads else None
+    used = read["used"] if read else estimated
+    quota = int(cc["monthly_quota"])
+    cartesia = {
+        "name": "Cartesia",
+        "key": bool(cartesia_key()),
+        "admin_key": bool(cartesia_admin_key()),
+        "voice_id": CFG["voice"]["cartesia"].get("voice_id") or None,
+        "plan": CARTESIA_PLANS[cc["plan"]][0] if cc["plan"] in CARTESIA_PLANS else "Outro",
+        "quota": quota,
+        "cycle_day": int(cc["cycle_day"]),
+        "used": used,
+        "source": "platform" if read else "estimated",
+        "read_at": read and read["at"],
+        "estimated": estimated,
+        "remaining": max(quota - used, 0),
+        "fraction": round(min(used / quota, 1.0), 4) if quota else 0.0,
+        "cycle": {"lines": len(c_lines), "chars": c_chars},
+    }
+
+    # --- VoiceStudio (local, no cost)
+    v_lines = [e for e in lines if e["provider"] == "voicestudio"]
+    local = {"name": "VoiceStudio", "lines": len(v_lines), "audio_s": round(_sum(v_lines, "audio_s"), 1)}
+
+    # --- by video
+    per = {}
+    for e in lines:
+        v = per.setdefault(
+            e.get("video") or "?",
+            {
+                "video": e.get("video") or "?",
+                "lines": 0,
+                "fish_usd": 0.0,
+                "cartesia_credits": 0,
+                "audio_s": 0.0,
+                "providers": set(),
+            },
+        )
+        v["lines"] += 1
+        v["audio_s"] += e.get("audio_s") or 0
+        v["providers"].add(e["provider"])
+        if _paid(e):
+            v["fish_usd"] += (e.get("bytes") or 0) * price / 1e6
+        elif e["provider"] == "cartesia":
+            v["cartesia_credits"] += (e.get("chars") or 0) * cc["credits_per_char"]
+    by_video = sorted(per.values(), key=lambda v: (v["fish_usd"], v["cartesia_credits"], v["lines"]), reverse=True)[:12]
+    for v in by_video:
+        v["fish_usd"] = round(v["fish_usd"], 6)
+        v["cartesia_credits"] = int(round(v["cartesia_credits"]))
+        v["audio_s"] = round(v["audio_s"], 1)
+        v["providers"] = sorted(v["providers"])
+
+    # --- recent runs (one per `voice`)
+    runs = {}
+    for e in evs:
+        rid = e.get("run")
+        if not rid or e.get("t") not in ("line", "failure", "balance", "cycle"):
+            continue
+        r = runs.setdefault(
+            rid,
+            {
+                "run": rid,
+                "at": e["at"],
+                "video": e.get("video"),
+                "providers": {},
+                "failures": [],
+                "_before": None,
+                "_after": None,
+            },
+        )
+        p = r["providers"].setdefault(e["provider"], {"lines": 0, "bytes": 0, "chars": 0, "audio_s": 0.0})
+        if e["t"] == "line":
+            p["lines"] += 1
+            p["bytes"] += e.get("bytes") or 0
+            if _paid(e):
+                p["bytes_paid"] = p.get("bytes_paid", 0) + (e.get("bytes") or 0)
+            elif e["provider"] == "fish":
+                p["lines_free"] = p.get("lines_free", 0) + 1
+            p["chars"] += e.get("chars") or 0
+            p["audio_s"] += e.get("audio_s") or 0
+        elif e["t"] == "failure":
+            r["failures"].append({"provider": e["provider"], "line": e.get("line"), "reason": e.get("reason")})
+        elif e["t"] == "balance" and e.get("moment") == "before":
+            r["_before"] = e
+        elif e["t"] == "balance" and e.get("moment") == "after":
+            r["_after"] = e
+    recent_runs = []
+    for r in sorted(runs.values(), key=lambda r: r["at"], reverse=True)[:15]:
+        a, d = r.pop("_before"), r.pop("_after")
+        for name, p in r["providers"].items():
+            p["audio_s"] = round(p["audio_s"], 1)
+            if name == "fish":
+                p["estimated_usd"] = round(p.get("bytes_paid", 0) * price / 1e6, 6)
+                if a and d and a.get("credit") is not None and d.get("credit") is not None:
+                    p["platform"] = round(max(a["credit"] - d["credit"], 0.0), 6)
+            if name == "cartesia":
+                p["estimated_credits"] = int(round(p["chars"] * cc["credits_per_char"]))
+        if r["failures"] or any(p["lines"] for p in r["providers"].values()):
+            recent_runs.append(r)
+
+    # --- warnings
+    warnings = []
+    if not fish["key"]:
+        warnings.append(f"Fish Audio sem chave: preencha {CFG['voice']['fish']['key_env']} no .env")
+    if not cartesia["key"]:
+        warnings.append(f"Cartesia sem chave: preencha {CFG['voice']['cartesia']['key_env']} no .env")
+    if cartesia["key"] and not cartesia["admin_key"]:
+        warnings.append(
+            f"Cartesia: sem {cc['admin_key_env']}. A API só mostra o consumo para chave admin "
+            f"(sk_car_admin_…); sem ela a tela estima pelos caracteres gerados aqui"
+        )
+    if quota and cartesia["fraction"] >= 0.8:
+        warnings.append(
+            f"Cartesia em {round(cartesia['fraction'] * 100)}% da cota do ciclo: sobram {cartesia['remaining']} créditos"
+        )
+    paid = [m for m in (fish["model"], fish["fallback_model"]) if m and not voice.is_free(m)]
+    if paid and fish["balance"]["credit"] is not None and fish["balance"]["credit"] <= 0:
+        warnings.append(
+            f"Fish Audio sem saldo na API: o {paid[0]} não gera, as falas caem para o próximo provider"
+            if paid[0] == fish["model"]
+            else f"Fish Audio sem saldo na API: se o {fish['model']} falhar, o {paid[0]} não gera e as falas "
+            f"caem para o próximo provider"
+        )
+
+    return {
+        "generated_at": iso(now()),
+        "cycle": {"start": iso(start), "end": iso(end)},
+        "fish": fish,
+        "cartesia": cartesia,
+        "voicestudio": local,
+        "by_video": by_video,
+        "runs": recent_runs,
+        "warnings": warnings,
+        "refresh": {"live": live, "errors": errors},
+    }
+
+
+# --- text output -------------------------------------------------------------
+
+SOURCE_LABEL = {"platform": "plataforma", "estimated": "estimado"}
+
+
+def _local(s):
+    if not s:
+        return "—"
+    return datetime.strptime(s, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=UTC).astimezone().strftime("%d/%m %H:%M")
+
+
+def _utc(s):
+    return datetime.strptime(s, "%Y-%m-%dT%H:%M:%SZ").strftime("%d/%m")
+
+
+def _lines(n):
+    return f"{n} fala" if n == 1 else f"{n} falas"
+
+
+def _n(v, places=0):
+    return "—" if v is None else f"{v:,.{places}f}".replace(",", ".")
+
+
+def text(r):
+    f, c, v = r["fish"], r["cartesia"], r["voicestudio"]
+    out = [f"uso das vozes · ciclo {_utc(r['cycle']['start'])} → {_utc(r['cycle']['end'])} (UTC)", ""]
+    out.append("Fish Audio · API pré-paga")
+    out.append(f"  modelo       {f['model']}" + (f" → {f['fallback_model']} se falhar" if f["fallback_model"] else ""))
+    out.append(f"  saldo        {_n(f['balance']['credit'], 4)}   (lido em {_local(f['balance']['at'])})")
+    out.append(
+        f"  no ciclo     {_lines(f['cycle']['lines'])} ({f['cycle']['lines_free']} free) · {_n(f['cycle']['bytes'])} bytes · "
+        f"estimado US$ {f['cycle']['estimated_usd']:.4f}"
+        + (f" · plataforma {_n(f['cycle']['platform'], 4)}" if f["cycle"]["platform"] is not None else "")
+    )
+    out.append("")
+    out.append(f"Cartesia · plano {c['plan']} · cota mensal")
+    out.append(
+        f"  usado        {_n(c['used'])} / {_n(c['quota'])} créditos ({round(c['fraction'] * 100)}%) · "
+        f"{SOURCE_LABEL.get(c['source'], c['source'])}" + (f", lido em {_local(c['read_at'])}" if c["read_at"] else "")
+    )
+    out.append(f"  restante     {_n(c['remaining'])}")
+    out.append(f"  no ciclo     {_lines(c['cycle']['lines'])} · {_n(c['cycle']['chars'])} caracteres gerados aqui")
+    out.append("")
+    out.append(f"VoiceStudio · local · {_lines(v['lines'])}, {_n(v['audio_s'])} s de áudio")
+    if r["by_video"]:
+        out += ["", "por vídeo (ciclo)"]
+        for p in r["by_video"]:
+            spent = []
+            if p["fish_usd"]:
+                spent.append(f"Fish ~US$ {p['fish_usd']:.4f}")
+            if p["cartesia_credits"]:
+                spent.append(f"Cartesia {_n(p['cartesia_credits'])} créditos")
+            out.append(f"  {p['video']:<40} {p['lines']:>3} fala(s)  {', '.join(spent) or 'local'}")
+    for w in r["warnings"]:
+        out.append(f"⚠ {w}")
+    for e in r["refresh"]["errors"]:
+        out.append(f"· {e}")
+    return "\n".join(out)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("command", nargs="?", default="summary", choices=["summary", "events", "keys"])
+    ap.add_argument("--json", action="store_true")
+    ap.add_argument("--live", action="store_true", help="pergunta às plataformas agora")
+    ap.add_argument("--n", type=int, default=30)
+    a = ap.parse_args()
+    if a.command == "events":
+        for e in events()[-a.n :]:
+            print(json.dumps(e, ensure_ascii=False))
+    elif a.command == "keys":
+        names = {
+            CFG["voice"]["fish"]["key_env"]: bool(fish_key()),
+            CFG["voice"]["cartesia"]["key_env"]: bool(cartesia_key()),
+            cfg()["cartesia"]["admin_key_env"]: bool(cartesia_admin_key()),
+        }
+        for k, ok in names.items():
+            print(f"{'✓' if ok else '·'} {k}{'' if ok else '  (vazia)'}")
+    else:
+        r = summary(live=a.live)
+        print(json.dumps(r, ensure_ascii=False) if a.json else text(r))
+
+
+if __name__ == "__main__":
+    main()