@indigoai-us/hq-cli 5.345.91 → 5.345.93

package/dist/lib/capacity/collectors/grok.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Grok billing collector (US-007).
+ *
+ * Reads the bearer from ~/.grok/auth.json (path injectable) and GETs
+ * https://cli-chat-proxy.grok.com/v1/billing?format=credits. The wire body
+ * is camelCase under `config` (US-001). Snake_case names from the October
+ * notes are drift, not a second dialect. This module does not refresh the
+ * token, write ~/.grok, start the daemon, or call the grok CLI except
+ * `grok --version` when the caller does not pass cliVersion.
+ *
+ * observedAt is the response time. Readings and parser failures from one
+ * response are appended in one rebuild. A missing creditUsagePercent never
+ * becomes a zero reading.
+ */
+import { type LedgerOptions, type NowView, type ParserFailureEvent, type ReadingInput } from "../ledger.js";
+export declare const GROK_PARSER_VERSION = "grok-billing.1";
+export declare const GROK_PROVIDER = "grok";
+export declare const GROK_SOURCE: "grok-billing";
+export declare const GROK_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+export declare const GROK_POLL_MS: number;
+export declare const GROK_FRESH_MS: number;
+export declare const GROK_POLL_FILE = "grok-last-call.json";
+export declare const GROK_FETCH_TIMEOUT_MS = 20000;
+export interface GrokFetchInit {
+    method: "GET";
+    headers: Record<string, string>;
+    redirect: "manual";
+    signal?: AbortSignal;
+}
+export type GrokFetch = (url: string, init: GrokFetchInit) => Promise<{
+    status: number;
+    text: () => Promise<string>;
+}>;
+export interface GrokCollectResult {
+    readings: ReadingInput[];
+    failures: ParserFailureEvent[];
+    view: NowView | null;
+    /** Set when the five-minute guard skipped the HTTP call. */
+    skipped?: "rate-limit" | "disabled";
+    accountId: string | null;
+}
+export interface CollectGrokOptions {
+    /** Defaults to ~/.grok/auth.json. Read-only. */
+    authPath?: string;
+    /** Full billing URL. Defaults to GROK_BILLING_URL. */
+    endpoint?: string;
+    /** Installed grok version. When set, grok --version is not run. */
+    cliVersion?: string;
+    /** Replaces `grok --version` output. Used when cliVersion is omitted. */
+    readVersion?: () => string;
+    now?: () => Date;
+    fetchImpl?: GrokFetch;
+    ledger?: LedgerOptions;
+    /** When set, read `<home>/auth.json` for each label instead of the single default file. */
+    accounts?: readonly {
+        label: string;
+        home: string;
+    }[];
+    /** One-shot collect reads while the resident collector stays disabled. */
+    allowDisabled?: boolean;
+}
+interface MapOptions {
+    observedAt: string;
+    cliVersion: string;
+    accountId: string;
+    accountLabel?: string;
+    accountLabels?: string[];
+    organization?: string | null;
+    accountHome?: string;
+}
+export declare function grokInstallSalt(root: string): Buffer;
+export declare function hashGrokAccountId(raw: string, salt?: Buffer): string;
+export declare function parseGrokCliVersion(text: string): string | null;
+export declare function grokPollPath(root: string): string;
+export declare function defaultGrokAuthPath(home?: string): string;
+export declare function readInstalledGrokVersion(readVersion?: () => string): string;
+/** Async `grok --version` for the daemon. The sync reader stays for one-shot callers. */
+export declare function readInstalledGrokVersionAsync(): Promise<string>;
+/** Map a billing JSON body. Does not read auth or call the network. */
+export declare function mapGrokBillingBody(body: unknown, options: MapOptions): {
+    readings: ReadingInput[];
+    failures: ParserFailureEvent[];
+};
+export declare function collectGrok(options?: CollectGrokOptions): Promise<GrokCollectResult>;
+export {};
+//# sourceMappingURL=grok.d.ts.map

package/dist/lib/capacity/collectors/grok.js

@@ -0,0 +1,588 @@
+/**
+ * Grok billing collector (US-007).
+ *
+ * Reads the bearer from ~/.grok/auth.json (path injectable) and GETs
+ * https://cli-chat-proxy.grok.com/v1/billing?format=credits. The wire body
+ * is camelCase under `config` (US-001). Snake_case names from the October
+ * notes are drift, not a second dialect. This module does not refresh the
+ * token, write ~/.grok, start the daemon, or call the grok CLI except
+ * `grok --version` when the caller does not pass cliVersion.
+ *
+ * observedAt is the response time. Readings and parser failures from one
+ * response are appended in one rebuild. A missing creditUsagePercent never
+ * becomes a zero reading.
+ */
+import { execFile, spawnSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DIR_MODE, FILE_MODE, appendReadings, capacityRoot, readCollectorMark, } from "../ledger.js";
+export const GROK_PARSER_VERSION = "grok-billing.1";
+export const GROK_PROVIDER = "grok";
+export const GROK_SOURCE = "grok-billing";
+export const GROK_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+export const GROK_POLL_MS = 5 * 60 * 1000;
+export const GROK_FRESH_MS = GROK_POLL_MS - 15_000;
+export const GROK_POLL_FILE = "grok-last-call.json";
+export const GROK_FETCH_TIMEOUT_MS = 20_000;
+const WEEKLY_MINUTES = 7 * 24 * 60;
+export function grokInstallSalt(root) {
+    const dest = path.join(root, "grok-install-salt");
+    try {
+        const existing = fs.readFileSync(dest);
+        if (existing.length >= 16)
+            return existing;
+    }
+    catch {
+        // Created below.
+    }
+    fs.mkdirSync(root, { recursive: true, mode: DIR_MODE });
+    const salt = crypto.randomBytes(32);
+    const tmp = `${dest}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, salt, { mode: FILE_MODE });
+    fs.renameSync(tmp, dest);
+    fs.chmodSync(dest, FILE_MODE);
+    return salt;
+}
+export function hashGrokAccountId(raw, salt) {
+    const digest = salt
+        ? crypto.createHmac("sha256", salt).update(raw, "utf8").digest("hex")
+        : crypto.createHash("sha256").update(raw, "utf8").digest("hex");
+    return `acct_${digest.slice(0, 16)}`;
+}
+export function parseGrokCliVersion(text) {
+    const match = /\b(\d+\.\d+\.\d+)\b/.exec(text);
+    return match?.[1] ?? null;
+}
+export function grokPollPath(root) {
+    return path.join(root, GROK_POLL_FILE);
+}
+export function defaultGrokAuthPath(home = os.homedir()) {
+    return path.join(home, ".grok", "auth.json");
+}
+export function readInstalledGrokVersion(readVersion = defaultGrokVersionText) {
+    try {
+        return parseGrokCliVersion(readVersion()) ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/** Async `grok --version` for the daemon. The sync reader stays for one-shot callers. */
+export function readInstalledGrokVersionAsync() {
+    return new Promise((resolve) => {
+        execFile("grok", ["--version"], { timeout: 5_000, encoding: "utf8", windowsHide: true }, (error, stdout, stderr) => {
+            if (error && !stdout && !stderr) {
+                resolve("unknown");
+                return;
+            }
+            resolve(parseGrokCliVersion(`${stdout ?? ""}\n${stderr ?? ""}`) ?? "unknown");
+        });
+    });
+}
+/** Map a billing JSON body. Does not read auth or call the network. */
+export function mapGrokBillingBody(body, options) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return { readings: [], failures: [failure(options, "grok billing response is not an object")] };
+    }
+    const root = body;
+    const configValue = root.config ?? root;
+    if (!configValue || typeof configValue !== "object" || Array.isArray(configValue)) {
+        return { readings: [], failures: [failure(options, "grok billing field drift: config")] };
+    }
+    const config = configValue;
+    if (!("creditUsagePercent" in config) || !isFiniteNumber(config.creditUsagePercent) || config.creditUsagePercent < 0) {
+        return { readings: [], failures: [failure(options, "grok billing field drift: creditUsagePercent")] };
+    }
+    const period = readPeriod(config.currentPeriod);
+    if (!period) {
+        return { readings: [], failures: [failure(options, "grok billing field drift: currentPeriod.end")] };
+    }
+    const planType = typeof config.subscriptionTier === "string" && config.subscriptionTier.trim()
+        ? config.subscriptionTier.trim()
+        : null;
+    if (options.accountLabel && options.organization === undefined) {
+        const tier = typeof config.tier === "string" && config.tier.trim() ? config.tier.trim() : null;
+        const named = typeof config.planType === "string" && config.planType.trim() ? config.planType.trim() : null;
+        options.organization = planType ?? named ?? tier;
+    }
+    const weeklyPercent = config.creditUsagePercent;
+    const readings = [
+        reading(options, {
+            limitId: "weekly",
+            kind: "weekly_all",
+            scope: null,
+            usedPercent: weeklyPercent,
+            windowMinutes: period.windowMinutes,
+            resetsAt: period.end,
+            balance: null,
+            planType,
+        }),
+    ];
+    const failures = [];
+    if ("prepaidBalance" in config) {
+        const prepaid = centVal(config.prepaidBalance);
+        if (prepaid === null) {
+            failures.push(failure(options, "grok billing field drift: prepaidBalance"));
+        }
+        else {
+            readings.push(reading(options, {
+                limitId: "prepaid",
+                kind: "prepaid",
+                scope: null,
+                usedPercent: null,
+                windowMinutes: null,
+                resetsAt: null,
+                balance: prepaid,
+                planType,
+            }));
+        }
+    }
+    if ("onDemandUsed" in config || "onDemandCap" in config) {
+        const used = centVal(config.onDemandUsed);
+        const cap = centVal(config.onDemandCap);
+        if (used === null || cap === null) {
+            failures.push(failure(options, "grok billing field drift: onDemandUsed"));
+        }
+        else {
+            readings.push(reading(options, {
+                limitId: "on_demand",
+                kind: "on_demand",
+                scope: null,
+                usedPercent: cap > 0 ? (used / cap) * 100 : null,
+                windowMinutes: null,
+                resetsAt: null,
+                balance: `${used}/${cap}`,
+                planType,
+            }));
+        }
+    }
+    if ("productUsage" in config) {
+        const products = config.productUsage;
+        if (!Array.isArray(products)) {
+            failures.push(failure(options, "grok billing field drift: productUsage"));
+        }
+        else {
+            const seen = new Set();
+            for (const item of products) {
+                const mapped = mapProduct(item);
+                if (!mapped) {
+                    failures.push(failure(options, "grok billing field drift: productUsage"));
+                    continue;
+                }
+                if (seen.has(mapped.product))
+                    continue;
+                seen.add(mapped.product);
+                readings.push(reading(options, {
+                    limitId: `product:${mapped.product}`,
+                    kind: "weekly_scoped",
+                    scope: mapped.product,
+                    usedPercent: mapped.usagePercent,
+                    windowMinutes: period.windowMinutes,
+                    resetsAt: period.end,
+                    balance: null,
+                    planType,
+                }));
+            }
+        }
+    }
+    return { readings, failures };
+}
+export async function collectGrok(options = {}) {
+    const ledger = ledgerOptions(options);
+    const root = ledger.root ?? capacityRoot(ledger.env, ledger.home);
+    const scoped = { ...ledger, root };
+    if (readCollectorMark(scoped)?.enabled === false && !options.allowDisabled) {
+        return { readings: [], failures: [], view: null, skipped: "disabled", accountId: null };
+    }
+    if (options.accounts)
+        return collectEnumeratedGrok(options);
+    const clock = options.now ?? ledger.now ?? (() => new Date());
+    const authPath = options.authPath ?? defaultGrokAuthPath(ledger.home);
+    const loaded = readGrokAuth(authPath, root);
+    if ("error" in loaded) {
+        const cliVersion = options.cliVersion ?? readInstalledGrokVersion(options.readVersion);
+        const accountId = hashGrokAccountId(`home:${path.resolve(path.dirname(authPath))}`);
+        const observedAt = clock().toISOString();
+        const failures = [failure({ observedAt, cliVersion, accountId }, loaded.error)];
+        const view = appendReadings([], failures, null, scoped);
+        return { readings: [], failures, view, accountId };
+    }
+    const accountId = loaded.auth.accountId;
+    const nowMs = clock().getTime();
+    if (pollIsFresh(root, accountId, nowMs)) {
+        return { readings: [], failures: [], view: null, skipped: "rate-limit", accountId };
+    }
+    const cliVersion = options.cliVersion ?? readInstalledGrokVersion(options.readVersion);
+    writePoll(root, accountId, new Date(nowMs).toISOString());
+    const endpoint = options.endpoint ?? GROK_BILLING_URL;
+    const fetchImpl = options.fetchImpl ?? defaultGrokFetch;
+    let status;
+    let text;
+    try {
+        const response = await fetchImpl(endpoint, grokBillingInit(loaded.auth, cliVersion));
+        status = response.status;
+        text = status === 200 ? await response.text() : "";
+    }
+    catch {
+        const observedAt = clock().toISOString();
+        const failures = [failure({ observedAt, cliVersion, accountId }, "grok billing request failed")];
+        const view = appendReadings([], failures, null, scoped);
+        return { readings: [], failures, view, accountId };
+    }
+    const observedAt = clock().toISOString();
+    const mapOptions = { observedAt, cliVersion, accountId };
+    if (status === 401) {
+        const failures = [failure(mapOptions, "grok billing unavailable: http 401")];
+        const view = appendReadings([], failures, null, scoped);
+        return { readings: [], failures, view, accountId };
+    }
+    if (status !== 200) {
+        const failures = [failure(mapOptions, `grok billing unavailable: http ${status}`)];
+        const view = appendReadings([], failures, null, scoped);
+        return { readings: [], failures, view, accountId };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        const failures = [failure(mapOptions, "grok billing response is not JSON")];
+        const view = appendReadings([], failures, null, scoped);
+        return { readings: [], failures, view, accountId };
+    }
+    const mapped = mapGrokBillingBody(parsed, mapOptions);
+    const view = appendReadings(mapped.readings, mapped.failures, null, scoped);
+    return { readings: mapped.readings, failures: mapped.failures, view, accountId };
+}
+function ledgerOptions(options) {
+    return { ...(options.ledger ?? {}) };
+}
+function grokBillingInit(auth, cliVersion) {
+    const headers = {
+        Authorization: `Bearer ${auth.bearer}`,
+        "X-XAI-Token-Auth": "xai-grok-cli",
+        Accept: "application/json",
+    };
+    if (auth.userId)
+        headers["x-userid"] = auth.userId;
+    const version = parseGrokCliVersion(cliVersion) ?? (cliVersion !== "unknown" ? cliVersion : null);
+    if (version)
+        headers["x-grok-client-version"] = version;
+    return {
+        method: "GET",
+        headers,
+        redirect: "manual",
+        signal: AbortSignal.timeout(GROK_FETCH_TIMEOUT_MS),
+    };
+}
+async function defaultGrokFetch(url, init) {
+    const response = await fetch(url, init);
+    return { status: response.status, text: () => response.text() };
+}
+function defaultGrokVersionText() {
+    const result = spawnSync("grok", ["--version"], {
+        encoding: "utf8",
+        timeout: 5_000,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    if (result.error)
+        throw result.error;
+    return `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+}
+function readGrokAuth(file, root) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? err.code : "";
+        return { error: code === "ENOENT" ? "grok auth file is missing" : "grok auth file is unreadable" };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { error: "grok auth file is not JSON" };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { error: "grok auth file is not an object" };
+    }
+    for (const value of Object.values(parsed)) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const record = value;
+        if (typeof record.key !== "string" || record.key.trim() === "")
+            continue;
+        const accountRaw = firstAccountKey(record, `home:${path.resolve(path.dirname(file))}`);
+        const userId = typeof record.user_id === "string" && record.user_id.trim() ? record.user_id.trim() : null;
+        return {
+            auth: {
+                bearer: record.key,
+                accountId: hashGrokMaterial(accountRaw, root),
+                userId,
+            },
+        };
+    }
+    return { error: "grok auth file has no bearer" };
+}
+function firstAccountKey(record, homeFallback) {
+    for (const field of ["user_id", "principal_id"]) {
+        const value = record[field];
+        if (typeof value === "string" && value.trim())
+            return `id:${value.trim()}`;
+    }
+    const email = record.email;
+    if (typeof email === "string" && email.includes("@"))
+        return `email:${email.trim()}`;
+    return homeFallback;
+}
+function hashGrokMaterial(raw, root) {
+    if (raw.startsWith("email:") && root)
+        return hashGrokAccountId(raw.slice("email:".length), grokInstallSalt(root));
+    const material = raw.startsWith("id:") ? raw.slice("id:".length) : raw;
+    return hashGrokAccountId(material);
+}
+function pollIsFresh(root, accountId, nowMs) {
+    const accounts = readPoll(grokPollPath(root));
+    const last = accounts[accountId];
+    if (!last)
+        return false;
+    const at = Date.parse(last);
+    if (Number.isNaN(at))
+        return false;
+    const delta = nowMs - at;
+    return delta >= 0 && delta < GROK_FRESH_MS;
+}
+function readPoll(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const accounts = parsed.accounts;
+        if (!accounts || typeof accounts !== "object" || Array.isArray(accounts))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(accounts)) {
+            if (typeof value === "string")
+                out[key] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function writePoll(root, accountId, at) {
+    fs.mkdirSync(root, { recursive: true, mode: DIR_MODE });
+    fs.chmodSync(root, DIR_MODE);
+    const dest = grokPollPath(root);
+    const accounts = readPoll(dest);
+    accounts[accountId] = at;
+    const body = `${JSON.stringify({ accounts }, null, 2)}\n`;
+    const tmp = path.join(root, `.${GROK_POLL_FILE}.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, body, { mode: FILE_MODE });
+    fs.renameSync(tmp, dest);
+    fs.chmodSync(dest, FILE_MODE);
+}
+function readPeriod(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const endRaw = record.end;
+    if (typeof endRaw !== "string")
+        return null;
+    const endMs = Date.parse(endRaw);
+    if (Number.isNaN(endMs))
+        return null;
+    const end = new Date(endMs).toISOString();
+    let windowMinutes = WEEKLY_MINUTES;
+    if (typeof record.start === "string") {
+        const startMs = Date.parse(record.start);
+        if (!Number.isNaN(startMs) && endMs > startMs) {
+            windowMinutes = Math.round((endMs - startMs) / 60_000);
+        }
+    }
+    return { end, windowMinutes };
+}
+function mapProduct(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const product = typeof record.product === "string" ? record.product.trim() : "";
+    if (!product)
+        return null;
+    if (!isFiniteNumber(record.usagePercent) || record.usagePercent < 0)
+        return null;
+    return { product, usagePercent: record.usagePercent };
+}
+function centVal(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const val = value.val;
+    if (!isFiniteNumber(val))
+        return null;
+    return val;
+}
+function reading(options, limit) {
+    const row = {
+        readingId: makeReadingId([
+            GROK_SOURCE,
+            options.accountId,
+            limit.limitId,
+            options.observedAt,
+            String(limit.usedPercent),
+            String(limit.balance),
+        ]),
+        observedAt: options.observedAt,
+        provider: GROK_PROVIDER,
+        accountId: options.accountId,
+        source: GROK_SOURCE,
+        cliVersion: options.cliVersion,
+        confidence: "fetched",
+        parserVersion: GROK_PARSER_VERSION,
+        limit,
+    };
+    return stampAccount(row, options, limit.planType);
+}
+function failure(options, error) {
+    const event = {
+        event: "parser_failure",
+        observedAt: options.observedAt,
+        provider: GROK_PROVIDER,
+        source: GROK_SOURCE,
+        error,
+        accountId: options.accountId,
+        cliVersion: options.cliVersion,
+        parserVersion: GROK_PARSER_VERSION,
+    };
+    return stampAccount(event, options, null);
+}
+function stampAccount(row, options, planType) {
+    if (!options.accountLabel)
+        return row;
+    row.accountLabel = options.accountLabel;
+    row.accountLabels = options.accountLabels ? [...options.accountLabels] : [options.accountLabel];
+    if (options.accountHome)
+        row.accountHome = options.accountHome;
+    row.organization = options.organization !== undefined ? options.organization : planType;
+    return row;
+}
+async function collectEnumeratedGrok(options) {
+    const ledger = ledgerOptions(options);
+    const root = ledger.root ?? capacityRoot(ledger.env, ledger.home);
+    const scoped = { ...ledger, root };
+    const clock = options.now ?? ledger.now ?? (() => new Date());
+    const cliVersion = options.cliVersion ?? readInstalledGrokVersion(options.readVersion);
+    const groups = new Map();
+    for (const account of options.accounts ?? []) {
+        const key = path.resolve(account.home);
+        const group = groups.get(key) ?? { home: account.home, labels: [] };
+        if (!group.labels.includes(account.label))
+            group.labels.push(account.label);
+        groups.set(key, group);
+    }
+    const pending = [];
+    const failures = [];
+    for (const group of groups.values()) {
+        const loaded = readGrokAuth(path.join(group.home, "auth.json"), root);
+        const label = group.labels.find((item) => item !== "default") ?? group.labels[0] ?? "default";
+        if ("error" in loaded) {
+            const accountId = hashGrokAccountId(`missing:${path.resolve(group.home)}`);
+            const reason = loaded.error === "grok auth file is missing"
+                ? "signed out: credential missing"
+                : "signed out: credential unreadable";
+            failures.push(failure({
+                observedAt: clock().toISOString(),
+                cliVersion,
+                accountId,
+                accountLabel: label,
+                accountLabels: group.labels,
+                accountHome: group.home,
+            }, reason));
+            continue;
+        }
+        const existing = pending.find((row) => row.auth.accountId === loaded.auth.accountId);
+        if (existing) {
+            for (const item of group.labels) {
+                if (!existing.labels.includes(item))
+                    existing.labels.push(item);
+            }
+            if (!existing.homes.includes(group.home))
+                existing.homes.push(group.home);
+            continue;
+        }
+        pending.push({ auth: loaded.auth, labels: [...group.labels], homes: [group.home] });
+    }
+    const readings = [];
+    const endpoint = options.endpoint ?? GROK_BILLING_URL;
+    const fetchImpl = options.fetchImpl ?? defaultGrokFetch;
+    const nowMs = clock().getTime();
+    let fetched = false;
+    for (const account of pending) {
+        if (pollIsFresh(root, account.auth.accountId, nowMs))
+            continue;
+        writePoll(root, account.auth.accountId, new Date(nowMs).toISOString());
+        fetched = true;
+        const label = account.labels.find((item) => item !== "default") ?? account.labels[0] ?? "default";
+        const observedAt = clock().toISOString();
+        const mapOptions = {
+            observedAt,
+            cliVersion,
+            accountId: account.auth.accountId,
+            accountLabel: label,
+            accountLabels: account.labels,
+            accountHome: account.homes[0],
+        };
+        let status;
+        let text;
+        try {
+            const response = await fetchImpl(endpoint, grokBillingInit(account.auth, cliVersion));
+            status = response.status;
+            text = status === 200 ? await response.text() : "";
+        }
+        catch {
+            failures.push(failure(mapOptions, "grok billing request failed"));
+            continue;
+        }
+        if (status === 401 || status === 403) {
+            failures.push(failure(mapOptions, "signed out: auth rejected"));
+            continue;
+        }
+        if (status !== 200) {
+            failures.push(failure(mapOptions, `grok billing unavailable: http ${status}`));
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            failures.push(failure(mapOptions, "grok billing response is not JSON"));
+            continue;
+        }
+        const mapped = mapGrokBillingBody(parsed, mapOptions);
+        readings.push(...mapped.readings);
+        failures.push(...mapped.failures);
+    }
+    const accountId = pending[0]?.auth.accountId ?? null;
+    if (!fetched && failures.length === 0) {
+        return { readings: [], failures: [], view: null, skipped: "rate-limit", accountId };
+    }
+    if (readings.length === 0 && failures.length === 0) {
+        return { readings, failures, view: null, accountId };
+    }
+    const view = appendReadings(readings, failures, null, scoped);
+    return { readings, failures, view, accountId };
+}
+function makeReadingId(parts) {
+    const digest = crypto.createHash("sha256").update(parts.join("\0"), "utf8").digest("hex").slice(0, 20);
+    return `rdg_${digest}`;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+//# sourceMappingURL=grok.js.map