@indigoai-us/hq-cli 5.345.91 → 5.345.93

package/dist/commands/capacity.js

@@ -0,0 +1,666 @@
+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 * as readline from "node:readline";
+import { LedgerCorrupt, LedgerMissing, READING_SOURCES, capacityRoot, nowViewJsonSchema, readCollectorMark, readLedgerEvents, readNow, rebuildNow, setCollectorEnabled, } from "../lib/capacity/ledger.js";
+import { listCapacityAccounts, registryAccountIds } from "../lib/capacity/accounts.js";
+import { claudeIdentityKeys } from "../lib/capacity/collectors/claude-oauth.js";
+import { projectCapacityView } from "../lib/capacity/project.js";
+import { capacityWidgetTimeZone, renderCapacityWidget } from "../lib/capacity/widget.js";
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { SignInUsageError, executeCapacityLogin, formatCredits, formatLoginText, formatRefreshLine, formatRoster, generateAccountId, loginJson, presentAccount, promptsAllowed, removeCapacityAccount, renameCapacityAccount, rosterFrom, } from "../lib/capacity/sign-in.js";
+import { ingestClaudeStatuslinePayload, installStatuslineSpoolScript } from "../lib/capacity/collectors/claude-statusline.js";
+import { CapacityUsageError, REFUSAL_HELP, ingestRefusal, } from "../lib/capacity/refusal.js";
+export const CAPACITY_SCHEMA_VERSION = nowViewJsonSchema.$id;
+export const DOCTOR_SCHEMA_VERSION = "hq-capacity-doctor.v1";
+export const PARSER_FAILURE_WINDOW_MS = 24 * 60 * 60 * 1000;
+/** now.json older than this is stale: the collector is not keeping the view current. */
+export const CAPACITY_STALE_MS = 5 * 60 * 1000;
+/** Short versions inside test/fixtures/capacity/cli-versions.json. */
+export const PINNED_CLI_VERSIONS = {
+    claude: "2.1.152",
+    codex: "0.162.1",
+    grok: "1.0.25",
+};
+const TABLE_HEADERS = [
+    "LIMIT ID",
+    "KIND",
+    "SCOPE",
+    "USED PERCENT",
+    "RESETS IN",
+    "CREDITS",
+    "PLAN",
+    "SOURCE",
+    "OBSERVED-AT AGE",
+    "STATE",
+];
+const HISTORY_HEADERS = [
+    "OBSERVED AT",
+    "PROVIDER",
+    "LIMIT ID",
+    "KIND",
+    "SCOPE",
+    "USED PERCENT",
+    "SOURCE",
+    "CLI VERSION",
+];
+export function capacityOptionsFromEnv(env = process.env) {
+    const raw = env.HQ_CAPACITY_NOW?.trim();
+    if (!raw)
+        return { env };
+    const parsed = Date.parse(raw);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`HQ_CAPACITY_NOW must be a UTC timestamp, got '${raw}'`);
+    }
+    return { env, now: () => new Date(raw) };
+}
+export function withSchemaVersion(view) {
+    return { ...view, schemaVersion: CAPACITY_SCHEMA_VERSION };
+}
+/** Stale when generatedAt is missing or older than five minutes. */
+export function capacityFreshness(generatedAt, nowMs) {
+    const at = Date.parse(generatedAt);
+    if (Number.isNaN(at)) {
+        return {
+            stale: true,
+            ageMs: 0,
+            message: "collector not running, numbers may be stale; last update unknown",
+        };
+    }
+    const ageMs = Math.max(0, nowMs - at);
+    const stale = ageMs > CAPACITY_STALE_MS;
+    return {
+        stale,
+        ageMs,
+        message: stale
+            ? `collector not running, numbers may be stale; last update ${formatAge(generatedAt, nowMs)}`
+            : null,
+    };
+}
+export function parseSince(since, nowMs) {
+    const relative = /^(\d+)(m|h|d)$/.exec(since.trim());
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unit = relative[2];
+        const ms = unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+        return nowMs - amount * ms;
+    }
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(since) && !Number.isNaN(Date.parse(since))) {
+        return Date.parse(since);
+    }
+    throw new Error(`--since must be a duration like 24h or a UTC timestamp, got '${since}'`);
+}
+export function selectReadings(events, filter = {}) {
+    return events.filter(isReading).filter((reading) => {
+        if (filter.provider && reading.provider !== filter.provider)
+            return false;
+        if (filter.sinceMs !== undefined && Date.parse(reading.observedAt) < filter.sinceMs)
+            return false;
+        return true;
+    });
+}
+export function formatCapacityTable(view, nowMs, accounts = []) {
+    if (view.providers.length === 0)
+        return "No readings.";
+    return view.providers.map((provider) => {
+        const head = `${provider.provider}  ${provider.state}`;
+        if (!provider.accounts || provider.accounts.length === 0) {
+            return `${head}\n${formatLimitTable(provider.limits, nowMs)}`;
+        }
+        const blocks = provider.accounts.map((account) => {
+            const labels = account.labels.map((label) => {
+                const row = accounts.find((item) => item.provider === provider.provider && item.label === label);
+                return row?.lanes === false ? `${label} (usage only)` : label;
+            }).join(", ");
+            const title = account.organization ? `${labels}  ${account.organization}` : labels;
+            const presented = presentAccount(account, provider.provider, os.homedir());
+            if (presented.state === "expired" || presented.state === "signed_out") {
+                const reason = presented.reason ?? account.reason ?? presented.state;
+                const fix = presented.command ? formatRefreshLine(provider.provider, presented.command) : "";
+                return fix ? `${title}\n${reason}\n${fix}` : `${title}\n${reason}`;
+            }
+            return `${title}\n${formatLimitTable(account.limits, nowMs)}`;
+        });
+        return [head, ...blocks].join("\n");
+    }).join("\n\n");
+}
+function formatLimitTable(limits, nowMs) {
+    const rows = limits.map((limit) => [
+        limit.limitId,
+        limit.kind,
+        cell(limit.scope),
+        limit.usedPercent === null ? "—" : `${limit.usedPercent}%`,
+        formatSpan(limit.secondsToReset),
+        formatCredits(limit.balance),
+        cell(limit.planType),
+        limit.source,
+        formatAge(limit.observedAt, nowMs),
+        limit.state,
+    ]);
+    return formatTable(TABLE_HEADERS, rows);
+}
+export function formatHistory(readings) {
+    if (readings.length === 0)
+        return "No readings.";
+    const rows = readings.map((reading) => [
+        reading.observedAt,
+        reading.provider,
+        reading.limit.limitId,
+        reading.limit.kind,
+        cell(reading.limit.scope),
+        reading.limit.usedPercent === null ? "—" : `${reading.limit.usedPercent}%`,
+        reading.source,
+        reading.cliVersion,
+    ]);
+    return formatTable(HISTORY_HEADERS, rows);
+}
+export function buildDoctorReport(options) {
+    const resolved = capacityClock(options);
+    const view = loadNow(resolved.options);
+    const events = readLedgerEvents(resolved.options);
+    const readings = selectReadings(events);
+    const cutoff = resolved.nowMs - PARSER_FAILURE_WINDOW_MS;
+    const parserFailures = events.filter(isParserFailure).filter((event) => {
+        const at = Date.parse(event.observedAt);
+        return at >= cutoff && at <= resolved.nowMs;
+    });
+    const sources = READING_SOURCES.map((source) => {
+        const hits = readings.filter((reading) => reading.source === source);
+        const last = hits[hits.length - 1];
+        return { source, lastSuccess: last?.observedAt ?? null };
+    });
+    const installed = new Map();
+    for (const reading of readings) {
+        const at = Date.parse(reading.observedAt);
+        const prev = installed.get(reading.provider);
+        if (!prev || at >= prev.at)
+            installed.set(reading.provider, { at, version: reading.cliVersion });
+    }
+    const names = new Set([
+        ...Object.keys(PINNED_CLI_VERSIONS),
+        ...readings.map((reading) => reading.provider),
+        ...view.providers.map((provider) => provider.provider),
+    ]);
+    const versions = [...names].sort((a, b) => a.localeCompare(b)).map((provider) => {
+        const pinned = PINNED_CLI_VERSIONS[provider] ?? null;
+        const seen = installed.get(provider)?.version ?? null;
+        return { provider, pinned, installed: seen, match: pinned !== null && seen === pinned };
+    });
+    const providers = view.providers.map((provider) => ({
+        provider: provider.provider,
+        state: provider.state,
+    }));
+    const freshness = capacityFreshness(view.generatedAt, resolved.nowMs);
+    return {
+        schemaVersion: DOCTOR_SCHEMA_VERSION,
+        collector: readCollectorMark(resolved.options)?.enabled ? "on" : "off",
+        sources,
+        versions,
+        parserFailures,
+        providers,
+        ok: providers.every((provider) => provider.state !== "unknown"),
+        stale: freshness.stale,
+        ageMs: freshness.ageMs,
+    };
+}
+export function formatDoctor(report) {
+    const sources = formatTable(["SOURCE", "LAST SUCCESS"], report.sources.map((source) => [source.source, source.lastSuccess ?? "—"]));
+    const versions = formatTable(["PROVIDER", "PINNED", "INSTALLED", "MATCH"], report.versions.map((version) => [
+        version.provider,
+        version.pinned ?? "—",
+        version.installed ?? "—",
+        version.match ? "yes" : "no",
+    ]));
+    const failures = report.parserFailures.length === 0
+        ? "none"
+        : report.parserFailures.map((event) => `${event.observedAt}  ${event.provider}  ${event.source}  ${event.error}`).join("\n");
+    const states = report.providers.length === 0
+        ? "none"
+        : report.providers.map((provider) => `${provider.provider}  ${provider.state}`).join("\n");
+    const warning = report.stale
+        ? report.ageMs === 0
+            ? "collector not running, numbers may be stale; last update unknown"
+            : `collector not running, numbers may be stale; last update ${formatSpan(Math.floor(report.ageMs / 1000))} ago`
+        : null;
+    return [
+        ...(warning ? [warning] : []),
+        `collector  ${report.collector}`,
+        sources,
+        versions,
+        "parser_failure (24h)",
+        failures,
+        "provider state",
+        states,
+    ].join("\n");
+}
+export function registerCapacityCommand(program) {
+    const capacity = program
+        .command("capacity")
+        .description("Show provider capacity from the local ledger (read-only; enable, login, and ingest write to it)")
+        .addHelpText("after", "\nCodex rate limits are read with `codex app-server` only when Codex has been idle for 30 minutes and no codex process is running. account/rateLimits/read does not refresh tokens, but starting app-server can still rewrite ~/.codex/auth.json for a managed ChatGPT login, so the read stays idle-gated.\n")
+        .option("--json", "Print now.json plus schemaVersion")
+        .option("--widget", "Print an HTML usage card for chat");
+    capacity.action((opts) => {
+        runCli(() => {
+            if (opts.json && opts.widget) {
+                throw new CapacityUsageError("--widget cannot be combined with --json");
+            }
+            const clock = capacityClock();
+            if (opts.widget) {
+                console.log(widgetStdout(clock.options, clock.nowMs));
+                return;
+            }
+            const presented = presentLedger(clock.options);
+            const view = presented.view;
+            const freshness = capacityFreshness(view.generatedAt, clock.nowMs);
+            if (freshness.message)
+                console.error(freshness.message);
+            const mark = readCollectorMark(clock.options);
+            const body = {
+                ...withSchemaVersion(view),
+                stale: freshness.stale,
+                ageMs: freshness.ageMs,
+                collectorEnabled: mark ? mark.enabled : null,
+            };
+            console.log(opts.json
+                ? JSON.stringify(body, null, 2)
+                : formatCapacityTable(view, clock.nowMs, presented.accounts));
+        });
+    });
+    capacity
+        .command("history")
+        .description("Print readings from the ledger event log")
+        .option("--provider <name>", "Only this provider")
+        .option("--since <when>", "Duration (24h, 7d, 30m) or a UTC timestamp")
+        .option("--json", "Print readings as JSON")
+        .action((opts, command) => {
+        runCli(() => {
+            const clock = capacityClock();
+            const sinceMs = opts.since ? parseSince(opts.since, clock.nowMs) : undefined;
+            const readings = selectReadings(readLedgerEvents(clock.options), {
+                provider: opts.provider,
+                sinceMs,
+            });
+            console.log(wantsJson(opts, command) ? JSON.stringify(readings, null, 2) : formatHistory(readings));
+        });
+    });
+    capacity
+        .command("doctor")
+        .description("Report last success, pinned versus installed CLI versions, and parser failures")
+        .option("--json", "Print JSON")
+        .action((opts, command) => {
+        runCli(() => {
+            const report = buildDoctorReport(capacityClock().options);
+            console.log(wantsJson(opts, command) ? JSON.stringify(report, null, 2) : formatDoctor(report));
+            if (!report.ok || report.stale)
+                process.exitCode = 1;
+        });
+    });
+    capacity
+        .command("enable")
+        .description("Create the ledger directory and mark the collector on")
+        .action(() => {
+        runCli(() => {
+            const options = capacityOptionsFromEnv();
+            setCollectorEnabled(true, options);
+            installStatuslineSpoolScript(capacityRoot(options.env ?? process.env, options.home));
+            rebuildNow(options);
+            console.log(`Collector on. ${capacityRoot(options.env ?? process.env)}`);
+        });
+    });
+    capacity
+        .command("disable")
+        .description("Mark the collector off without deleting readings")
+        .action(() => {
+        runCli(() => {
+            const options = capacityOptionsFromEnv();
+            setCollectorEnabled(false, options);
+            console.log(`Collector off. ${capacityRoot(options.env ?? process.env)}`);
+        });
+    });
+    const ingest = capacity
+        .command("ingest")
+        .description("Record a provider capacity reading");
+    ingest
+        .command("claude-statusline")
+        .description("Read one Claude Code statusline JSON payload from stdin and record its rate limits")
+        .action(() => {
+        runCli(() => {
+            if (process.stdin.isTTY) {
+                console.error("claude-statusline ingest reads a payload on stdin, not a terminal.");
+                process.exitCode = 1;
+                return;
+            }
+            const text = fs.readFileSync(0, "utf8");
+            const result = ingestClaudeStatuslinePayload(text, capacityOptionsFromEnv());
+            if (result.error) {
+                console.error(result.error);
+                process.exitCode = 1;
+                return;
+            }
+            if (result.failures.length > 0) {
+                console.error(result.failures.map((item) => item.error).join("\n"));
+            }
+            const count = result.readings.length;
+            console.log(count === 0 ? "No rate limits in payload." : `Recorded ${count} readings.`);
+        });
+    });
+    ingest
+        .command("refusal")
+        .description("Record a classified provider rate-limit refusal as an exhausted reading")
+        .option("--provider <name>", "claude, codex, or grok")
+        .option("--limit-id <id>", "Limit to mark; default is the provider's weekly_all id in now.json, else weekly")
+        .option("--resets-at <when>", "UTC timestamp or epoch when this limit resets")
+        .option("--account <hash>", "Hashed account id; default is the account on the chosen limit")
+        .option("--json", "Print the recorded limit as JSON")
+        .addHelpText("after", `\n${REFUSAL_HELP}\n`)
+        .action((opts, command) => {
+        runCli(() => {
+            const record = ingestRefusal({
+                provider: opts.provider,
+                limitId: opts.limitId,
+                resetsAt: opts.resetsAt,
+                accountId: opts.account,
+            }, capacityOptionsFromEnv());
+            if (wantsJson(opts, command)) {
+                console.log(JSON.stringify(record, null, 2));
+                return;
+            }
+            console.log(`Recorded refusal for ${record.provider} ${record.limitId}; state ${record.state}.`);
+        });
+    });
+    capacity
+        .command("login")
+        .description("Show signed-in accounts, or sign into a provider through hq lanes accounts login")
+        .argument("[provider]", "claude, codex, or grok")
+        .option("--account <name>", "Registry account id. Omit to name it from the organization after the first read")
+        .option("--repair", "Sign in again for signed-out accounts. Expired accounts are listed, not logged in again")
+        .option("--json", "Print the account list and commands as JSON. Never prompts")
+        .action(async (provider, opts, command) => {
+        try {
+            process.exitCode = 0;
+            const clock = capacityClock();
+            const rows = readRoster(clock.options);
+            const interactive = promptsAllowed({
+                stdinTty: Boolean(process.stdin.isTTY),
+                stdoutTty: Boolean(process.stdout.isTTY),
+                json: wantsJson(opts, command),
+            });
+            const result = await executeCapacityLogin({
+                provider,
+                account: opts.account,
+                repair: opts.repair,
+                json: wantsJson(opts, command),
+                interactive,
+            }, {
+                rows,
+                nowMs: clock.nowMs,
+                ask: confirmSignIn,
+                loginAccount: (name, accountId) => loginThroughLanes(name, accountId),
+                readAccount: async (name, accountId, home) => {
+                    const { collectCapacityOnce } = await import("../lib/capacity/collect.js");
+                    return collectCapacityOnce({
+                        accounts: [{ provider: parseProvider(name), label: accountId, home, source: "registry" }],
+                        env: process.env,
+                        hqRoot: lanesRoot(),
+                        includeSpool: false,
+                    });
+                },
+                renameAccount: (name, from, to) => renameCapacityAccount(lanesRoot(), name, from, to),
+                takenIds: (name) => registryAccountIds(lanesRoot(), name),
+                formatReading: (view, name, label, home) => formatAccountUsage(view, name, label, home, capacityClock().nowMs),
+                newAccountId: () => generateAccountId(crypto.randomBytes(4).toString("hex")),
+            });
+            if (wantsJson(opts, command)) {
+                console.log(JSON.stringify(result.json ?? loginJson(rows, clock.nowMs, provider), null, 2));
+                return;
+            }
+            console.log(result.text);
+        }
+        catch (err) {
+            failCapacity(err);
+        }
+    });
+    const accounts = capacity
+        .command("accounts")
+        .description("List provider accounts from the registry and default homes")
+        .option("--json", "Print JSON")
+        .action((opts, command) => {
+        runCli(() => {
+            const clock = capacityClock();
+            const rows = readRoster(clock.options);
+            if (wantsJson(opts, command)) {
+                console.log(JSON.stringify(loginJson(rows, clock.nowMs), null, 2));
+                return;
+            }
+            console.log(rows.length === 0 ? "No accounts." : formatRoster(rows, clock.nowMs));
+        });
+    });
+    accounts
+        .command("rename")
+        .description("Rename a registry account id. Does not touch the provider credential")
+        .argument("<provider>", "claude, codex, or grok")
+        .argument("<id>", "Current account id")
+        .argument("<new-id>", "New account id")
+        .option("--force", "Rename even when a live lane references the account")
+        .action((provider, id, newId, opts) => {
+        runCli(() => {
+            renameCapacityAccount(lanesRoot(), provider, id, newId, { force: opts.force });
+            console.log(`Renamed ${provider} account ${id} to ${newId}.`);
+        });
+    });
+    accounts
+        .command("remove")
+        .description("Forget a registry account. Does not delete its home unless --delete-home is set")
+        .argument("<provider>", "claude, codex, or grok")
+        .argument("<id>", "Account id")
+        .option("--delete-home", "Delete the account home. Refuses the default provider home, the home directory, and any path outside ~/.provider-id")
+        .option("--force", "Rename or remove even when a live lane references the account")
+        .action((provider, id, opts) => {
+        runCli(() => {
+            const result = removeCapacityAccount(lanesRoot(), provider, id, {
+                deleteHome: opts.deleteHome,
+                force: opts.force,
+                hostname: os.hostname(),
+                homedir: os.homedir,
+            });
+            console.log(result.removedHome
+                ? `Removed ${provider} account ${id} and deleted its home.`
+                : `Removed ${provider} account ${id}.`);
+        });
+    });
+    return capacity;
+}
+function readRoster(options) {
+    const presented = presentLedger(options, { missingOk: true });
+    return rosterFrom(presented.accounts, presented.view, os.homedir());
+}
+function widgetStdout(options, nowMs) {
+    const timeZone = capacityWidgetTimeZone(options.env ?? process.env);
+    try {
+        const presented = presentLedger(options);
+        const freshness = capacityFreshness(presented.view.generatedAt, nowMs);
+        const mark = readCollectorMark(options);
+        return renderCapacityWidget({
+            view: presented.view,
+            accounts: presented.accounts,
+            nowMs,
+            timeZone,
+            stale: freshness.stale,
+            collectorEnabled: mark ? mark.enabled : null,
+        });
+    }
+    catch (err) {
+        if (!(err instanceof LedgerMissing))
+            throw err;
+        return renderCapacityWidget({ nowMs, timeZone, ledgerMissing: true });
+    }
+}
+function presentLedger(options, mode = {}) {
+    const accounts = listCapacityAccounts({
+        env: options.env,
+        hqRoot: options.env?.HQ_ROOT,
+        home: options.home ?? options.env?.HOME,
+    });
+    let stored;
+    try {
+        stored = loadNow(options);
+    }
+    catch (err) {
+        if (!(err instanceof LedgerMissing) || !mode.missingOk)
+            throw err;
+        const now = options.now ? options.now() : new Date();
+        stored = {
+            machineId: "local",
+            hqCliVersion: "unknown",
+            generatedAt: now.toISOString(),
+            providers: [],
+        };
+    }
+    const root = options.root ?? capacityRoot(options.env ?? process.env, options.home);
+    const identityKeys = claudeIdentityKeys(root);
+    return {
+        accounts,
+        view: projectCapacityView(stored, {
+            accounts,
+            identityKeyForAccount: (accountId) => identityKeys.get(accountId) ?? null,
+        }),
+    };
+}
+function formatAccountUsage(view, provider, label, home, nowMs) {
+    const group = view.providers.find((item) => item.provider === provider);
+    const resolved = path.resolve(home);
+    const account = group?.accounts?.find((item) => item.homes.some((itemHome) => path.resolve(itemHome) === resolved));
+    if (!group || !account)
+        return formatLoginText([], nowMs);
+    const titled = {
+        ...account,
+        labels: [label, ...account.labels.filter((item) => item !== label)],
+    };
+    return formatCapacityTable({
+        ...view,
+        providers: [{ ...group, accounts: [titled] }],
+    }, nowMs);
+}
+function parseProvider(value) {
+    if (value === "claude" || value === "codex" || value === "grok")
+        return value;
+    throw new SignInUsageError(`Unknown provider ${value}. Expected claude, codex, or grok.`);
+}
+function lanesRoot() {
+    return resolveLanesHqRoot({ env: process.env });
+}
+async function loginThroughLanes(provider, accountId) {
+    const { loginLaneAccount } = await import("../lib/capacity/lane-login.js");
+    return loginLaneAccount({
+        provider,
+        accountId,
+        hqRoot: lanesRoot(),
+        env: process.env,
+    });
+}
+function confirmSignIn(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            rl.close();
+            resolve(value);
+        };
+        rl.once("close", () => finish(false));
+        rl.question(`${question} [y/N] `, (answer) => {
+            finish(/^y(es)?$/i.test(answer.trim()));
+        });
+    });
+}
+function failCapacity(err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = err instanceof SignInUsageError ? 2 : 1;
+}
+function wantsJson(opts, command) {
+    // The root program parses tokens before the subcommand name, so a shared
+    // --json flag is stored on `capacity` when it appears before another flag.
+    if (opts.json)
+        return true;
+    let parent = command.parent;
+    while (parent) {
+        if (parent.opts().json)
+            return true;
+        parent = parent.parent;
+    }
+    return false;
+}
+function runCli(action) {
+    try {
+        process.exitCode = 0;
+        action();
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = err instanceof CapacityUsageError ? 2 : 1;
+    }
+}
+function loadNow(options) {
+    try {
+        return readNow(options);
+    }
+    catch (err) {
+        if (!(err instanceof LedgerCorrupt))
+            throw err;
+        console.error(err.message);
+        return rebuildNow(options);
+    }
+}
+function capacityClock(options) {
+    const resolved = options ?? capacityOptionsFromEnv();
+    const nowMs = resolved.now ? resolved.now().getTime() : Date.now();
+    return { options: resolved, nowMs };
+}
+function isReading(event) {
+    return !("event" in event);
+}
+function isParserFailure(event) {
+    return "event" in event && event.event === "parser_failure";
+}
+function cell(value) {
+    if (value === null || value === "")
+        return "—";
+    return String(value);
+}
+function formatSpan(seconds) {
+    if (seconds === null)
+        return "—";
+    const span = Math.max(0, Math.floor(seconds));
+    if (span < 60)
+        return `${span}s`;
+    const minutes = Math.floor(span / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    const remainMinutes = minutes % 60;
+    if (hours < 48)
+        return remainMinutes === 0 ? `${hours}h` : `${hours}h ${remainMinutes}m`;
+    const days = Math.floor(hours / 24);
+    const remainHours = hours % 24;
+    return remainHours === 0 ? `${days}d` : `${days}d ${remainHours}h`;
+}
+function formatAge(observedAt, nowMs) {
+    const at = Date.parse(observedAt);
+    if (Number.isNaN(at))
+        return "—";
+    return `${formatSpan(Math.floor((nowMs - at) / 1000))} ago`;
+}
+function formatTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+    const render = (row) => row.map((entry, index) => entry.padEnd(widths[index] ?? 0)).join("  ");
+    const lines = [render([...headers])];
+    if (rows.length > 0)
+        lines.push(render(widths.map((width) => "-".repeat(width))));
+    lines.push(...rows.map(render));
+    return lines.join("\n");
+}
+//# sourceMappingURL=capacity.js.map