@swarmify/agents-cli 1.13.3 → 1.14.0

package/dist/lib/usage.js

@@ -1,686 +0,0 @@
-/**
- * Usage and rate-limit tracking for Claude and Codex agents.
- *
- * Fetches live usage data from the Anthropic OAuth API (Claude) or parses
- * rate-limit events from Codex session logs. Results are normalized into a
- * common UsageSnapshot shape, cached to disk, and rendered as terminal
- * progress bars for the `agents view` and `agents status` commands.
- */
-import { execFile } from 'child_process';
-import { createHash } from 'crypto';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import * as readline from 'readline';
-import { promisify } from 'util';
-import chalk from 'chalk';
-import { getAgentsDir } from './state.js';
-import { walkForFiles } from './session/discover.js';
-const execFileAsync = promisify(execFile);
-const CLAUDE_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
-const CLAUDE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
-const CLAUDE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
-const CLAUDE_OAUTH_BETA_HEADER = 'oauth-2025-04-20';
-const CLAUDE_REFRESH_LEEWAY_MS = 5 * 60 * 1000;
-const CLAUDE_SCOPES = [
-    'user:profile',
-    'user:inference',
-    'user:sessions:claude_code',
-    'user:mcp_servers',
-    'user:file_upload',
-];
-const CLAUDE_KEYCHAIN_SERVICE = 'Claude Code-credentials';
-const getClaudeUsageCachePath = () => path.join(getAgentsDir(), 'cache', 'claude-usage.json');
-const CACHED_CLAUDE_USAGE_SOURCE_LABEL = 'last seen live account data';
-const COMPACT_BAR_LEN = 5;
-const USAGE_BAR_LEN = 10;
-const FULL = '\u2588';
-const EMPTY = '\u2591';
-/** Fetch usage info for a given agent, dispatching to the agent-specific implementation. */
-export async function getUsageInfo(agentId, options) {
-    switch (agentId) {
-        case 'claude':
-            return getClaudeUsageInfo(options);
-        case 'codex':
-            return getCodexUsageInfo(options);
-        default:
-            return { snapshot: null, error: null };
-    }
-}
-/** Derive a stable lookup key from account info for usage deduplication. */
-export function getUsageLookupKey(info) {
-    return info?.usageKey || info?.accountKey || null;
-}
-/**
- * Deduplicate identity inputs into canonical (most-recently-active) accounts
- * and build the corresponding fetch inputs for each unique usage key.
- */
-export function buildCanonicalUsageContext(inputs) {
-    const canonicalByUsageKey = new Map();
-    const usageFetchInputs = new Map();
-    for (const input of inputs) {
-        const key = getUsageLookupKey(input.info);
-        if (!key)
-            continue;
-        const existing = canonicalByUsageKey.get(key);
-        const existingMs = existing?.lastActive?.getTime() ?? -1;
-        const currentMs = input.info.lastActive?.getTime() ?? -1;
-        if (existing && existingMs >= currentMs) {
-            continue;
-        }
-        canonicalByUsageKey.set(key, input.info);
-        usageFetchInputs.set(key, {
-            agentId: input.agentId,
-            home: input.home,
-            cliVersion: input.cliVersion || null,
-            organizationId: input.info.organizationId,
-        });
-    }
-    return { canonicalByUsageKey, usageFetchInputs };
-}
-/** Fetch usage info for all unique accounts in parallel, keyed by usage key. */
-export async function getUsageInfoByIdentity(inputs) {
-    const { canonicalByUsageKey, usageFetchInputs } = buildCanonicalUsageContext(inputs);
-    const usageResults = await Promise.all([...usageFetchInputs.entries()].map(async ([key, input]) => ({
-        key,
-        usage: await getUsageInfoForIdentity({
-            agentId: input.agentId,
-            home: input.home,
-            cliVersion: input.cliVersion,
-            info: canonicalByUsageKey.get(key),
-        }),
-    })));
-    return {
-        canonicalByUsageKey,
-        usageByKey: new Map(usageResults.map(({ key, usage }) => [key, usage])),
-    };
-}
-const USAGE_CACHE_FRESH_MS = 2 * 60 * 1000; // 2 minutes
-/**
- * Fetch usage for a single identity, with a 2-minute cache fast path.
- * Falls back to cached data when the live fetch fails.
- */
-export async function getUsageInfoForIdentity(input) {
-    const usageKey = getUsageLookupKey(input.info);
-    // Fast path: serve from cache if fresh. Skips the network call entirely.
-    if (input.agentId === 'claude' && usageKey) {
-        const cached = readClaudeUsageCache(usageKey);
-        if (cached?.capturedAt) {
-            const ageMs = Date.now() - cached.capturedAt.getTime();
-            if (ageMs < USAGE_CACHE_FRESH_MS) {
-                return { snapshot: cached, error: null };
-            }
-        }
-    }
-    // Cache miss or stale -- make the network call.
-    const usage = await getUsageInfo(input.agentId, {
-        home: input.home,
-        cliVersion: input.cliVersion,
-        organizationId: input.info.organizationId,
-    });
-    if (input.agentId !== 'claude' || !usageKey) {
-        return usage;
-    }
-    if (usage.snapshot?.source === 'live') {
-        writeClaudeUsageCache(usageKey, usage.snapshot);
-        return usage;
-    }
-    const cached = readClaudeUsageCache(usageKey);
-    if (cached) {
-        return { snapshot: cached, error: usage.error };
-    }
-    return usage;
-}
-/** Format a one-line usage summary with compact bars for inline display. */
-export function formatUsageSummary(plan, snapshot, planWidth = 3) {
-    const parts = [];
-    if (plan) {
-        parts.push(chalk.gray(plan.padEnd(planWidth)));
-    }
-    if (snapshot) {
-        const windows = snapshot.windows
-            .filter((window) => window.key !== 'sonnet_week')
-            .map((window) => `${chalk.gray(`${window.shortLabel}:`)} ${renderCompactUsageBar(window.usedPercent)}`);
-        if (windows.length > 0) {
-            parts.push(windows.join(' '));
-        }
-    }
-    return parts.join('  ');
-}
-/** Format a multi-line usage section for detailed agent views. */
-export function formatUsageSection(usage) {
-    if (!usage.snapshot && !usage.error) {
-        return [];
-    }
-    const lines = ['  Usage', ''];
-    if (!usage.snapshot) {
-        lines.push(`    ${chalk.dim(usage.error || 'Usage data unavailable right now.')}`);
-        return lines;
-    }
-    const labelWidth = usage.snapshot.windows.reduce((max, window) => Math.max(max, window.label.length), 0);
-    for (const window of usage.snapshot.windows) {
-        const bar = renderUsageBar(window.usedPercent);
-        lines.push(`    ${chalk.bold(window.label.padEnd(labelWidth))}  ${bar} ${formatPercent(window.usedPercent)}% used`);
-        if (window.resetsAt) {
-            lines.push(`    ${chalk.dim(`Resets ${formatResetAt(window.resetsAt)}`)}`);
-        }
-        lines.push('');
-    }
-    if (lines[lines.length - 1] === '') {
-        lines.pop();
-    }
-    lines.push(`    ${chalk.dim(`Source: ${usage.snapshot.sourceLabel}`)}`);
-    return lines;
-}
-/** Fetch Codex usage by scanning the most recent session files for rate-limit events. */
-async function getCodexUsageInfo(options) {
-    try {
-        const files = collectCodexSessionFiles(options?.home);
-        for (const filePath of files) {
-            const match = await readLatestCodexRateLimits(filePath);
-            if (!match)
-                continue;
-            const windows = normalizeCodexWindows(match.rateLimits);
-            if (windows.length === 0)
-                continue;
-            return {
-                snapshot: {
-                    source: 'last_seen',
-                    sourceLabel: 'last seen in latest Codex session',
-                    capturedAt: match.capturedAt,
-                    windows,
-                },
-                error: null,
-            };
-        }
-        return { snapshot: null, error: null };
-    }
-    catch {
-        return { snapshot: null, error: null };
-    }
-}
-/** Fetch Claude usage via the Anthropic OAuth usage API. */
-async function getClaudeUsageInfo(options) {
-    try {
-        const oauth = await loadClaudeOauth(options?.home);
-        if (!oauth?.accessToken) {
-            return { snapshot: null, error: null };
-        }
-        const requestedOrgId = normalizeString(options?.organizationId);
-        const liveOrgId = normalizeString(oauth.organizationUuid);
-        if (!isClaudeUsageOrgMatch(requestedOrgId, liveOrgId)) {
-            return { snapshot: null, error: null };
-        }
-        const accessToken = await getClaudeAccessToken(oauth);
-        if (!accessToken) {
-            return { snapshot: null, error: null };
-        }
-        const response = await fetch(CLAUDE_USAGE_URL, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                'Content-Type': 'application/json',
-                'anthropic-beta': CLAUDE_OAUTH_BETA_HEADER,
-                'User-Agent': getClaudeUserAgent(options?.cliVersion),
-            },
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!response.ok) {
-            return { snapshot: null, error: formatClaudeUsageError(response.status) };
-        }
-        const data = await response.json();
-        const windows = normalizeClaudeWindows(data);
-        if (windows.length === 0) {
-            return { snapshot: null, error: null };
-        }
-        return {
-            snapshot: {
-                source: 'live',
-                sourceLabel: 'live account data',
-                capturedAt: new Date(),
-                windows,
-            },
-            error: null,
-        };
-    }
-    catch {
-        return { snapshot: null, error: 'Usage data unavailable right now.' };
-    }
-}
-/** Collect Codex JSONL session files sorted newest-first. */
-function collectCodexSessionFiles(home) {
-    const base = home || os.homedir();
-    const dir = path.join(base, '.codex', 'sessions');
-    if (!fs.existsSync(dir))
-        return [];
-    const seenFiles = new Set();
-    const files = [];
-    for (const filePath of walkForFiles(dir, '.jsonl', 20)) {
-        const real = safeRealpathSync(filePath) || filePath;
-        if (seenFiles.has(real))
-            continue;
-        seenFiles.add(real);
-        const stat = safeStatSync(filePath);
-        if (!stat)
-            continue;
-        files.push({ path: filePath, mtime: stat.mtimeMs });
-    }
-    files.sort((a, b) => b.mtime - a.mtime);
-    return files.map((file) => file.path);
-}
-/** Stream a Codex JSONL file and return the last rate_limits payload found. */
-async function readLatestCodexRateLimits(filePath) {
-    return new Promise((resolve) => {
-        let latest = null;
-        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-        rl.on('line', (line) => {
-            if (!line.trim())
-                return;
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed.type !== 'event_msg' || parsed.payload?.type !== 'token_count' || !parsed.payload?.rate_limits) {
-                    return;
-                }
-                latest = {
-                    capturedAt: parseDateValue(parsed.timestamp),
-                    rateLimits: parsed.payload.rate_limits,
-                };
-            }
-            catch {
-                /* malformed session line */
-            }
-        });
-        rl.on('close', () => resolve(latest));
-        rl.on('error', () => resolve(latest));
-    });
-}
-/** Normalize Codex rate-limit windows into the common UsageWindow shape. */
-function normalizeCodexWindows(rateLimits) {
-    const windows = [];
-    const primary = normalizeCodexWindow(rateLimits.primary, 'session', 'Current session', 'S');
-    if (primary)
-        windows.push(primary);
-    const secondary = normalizeCodexWindow(rateLimits.secondary, 'week', 'Current week', 'W');
-    if (secondary)
-        windows.push(secondary);
-    return windows;
-}
-/** Normalize a single Codex rate-limit window. */
-function normalizeCodexWindow(window, key, label, shortLabel) {
-    const usedPercent = normalizePercent(window?.used_percent);
-    if (usedPercent === null)
-        return null;
-    return {
-        key,
-        label,
-        shortLabel,
-        usedPercent,
-        resetsAt: parseDateValue(window?.resets_at),
-        windowMinutes: normalizeWindowMinutes(window?.window_minutes),
-    };
-}
-/** Normalize Claude API usage windows into the common UsageWindow shape. */
-function normalizeClaudeWindows(data) {
-    const windows = [
-        normalizeClaudeWindow(data.five_hour, 'session', 'Current session', 'S'),
-        normalizeClaudeWindow(data.seven_day, 'week', 'Current week (all models)', 'W'),
-        normalizeClaudeWindow(data.seven_day_sonnet, 'sonnet_week', 'Current week (Sonnet only)', 'So'),
-    ];
-    return windows.filter((window) => window !== null);
-}
-/** Normalize a single Claude API usage window. */
-function normalizeClaudeWindow(window, key, label, shortLabel) {
-    const usedPercent = normalizePercent(window?.utilization);
-    if (usedPercent === null)
-        return null;
-    return {
-        key,
-        label,
-        shortLabel,
-        usedPercent,
-        resetsAt: parseDateValue(window?.resets_at),
-        windowMinutes: inferWindowMinutes(key),
-    };
-}
-/** Load Claude OAuth credentials from the macOS Keychain. */
-export async function loadClaudeOauth(home) {
-    if (process.platform !== 'darwin') {
-        return null;
-    }
-    try {
-        const account = os.userInfo().username;
-        const { stdout } = await execFileAsync('security', [
-            'find-generic-password',
-            '-a',
-            account,
-            '-s',
-            // Managed Claude homes must stay pinned to their own service name.
-            getClaudeKeychainService(home),
-            '-w',
-        ]);
-        const payload = JSON.parse(stdout.trim());
-        if (!payload.claudeAiOauth) {
-            return null;
-        }
-        return {
-            ...payload.claudeAiOauth,
-            organizationUuid: normalizeString(payload.organizationUuid),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Derive the Keychain service name for a Claude home directory.
- * Managed (non-default) homes get a hash suffix for isolation.
- */
-export function getClaudeKeychainService(home) {
-    if (!home) {
-        return CLAUDE_KEYCHAIN_SERVICE;
-    }
-    const configDir = path.join(home, '.claude').normalize('NFC');
-    const hash = createHash('sha256').update(configDir).digest('hex').slice(0, 8);
-    return `${CLAUDE_KEYCHAIN_SERVICE}-${hash}`;
-}
-/**
- * Check whether a requested org ID matches the live OAuth org ID.
- * Returns true when either is absent (no filtering) or when they match.
- */
-export function isClaudeUsageOrgMatch(requestedOrgId, liveOrgId) {
-    const requested = normalizeString(requestedOrgId);
-    const live = normalizeString(liveOrgId);
-    return !requested || !live || requested === live;
-}
-/** Read a cached usage snapshot for a given usage key. Returns null if absent or stale. */
-export function readClaudeUsageCache(usageKey, cachePath = getClaudeUsageCachePath(), now = new Date()) {
-    const cache = readClaudeUsageCacheFile(cachePath);
-    const cached = cache[usageKey];
-    if (!cached) {
-        return null;
-    }
-    const snapshot = deserializeClaudeUsageSnapshot(cached, now);
-    if (!snapshot) {
-        delete cache[usageKey];
-        writeClaudeUsageCacheFile(cache, cachePath);
-    }
-    return snapshot;
-}
-/** Write a usage snapshot to the on-disk cache. */
-export function writeClaudeUsageCache(usageKey, snapshot, cachePath = getClaudeUsageCachePath()) {
-    const cache = readClaudeUsageCacheFile(cachePath);
-    cache[usageKey] = serializeClaudeUsageSnapshot(snapshot);
-    writeClaudeUsageCacheFile(cache, cachePath);
-}
-/** Read the entire usage cache file from disk. */
-function readClaudeUsageCacheFile(cachePath) {
-    if (!fs.existsSync(cachePath)) {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
-        return parsed && typeof parsed === 'object' ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-/** Write the entire usage cache to disk. Best-effort; failures are silent. */
-function writeClaudeUsageCacheFile(cache, cachePath) {
-    try {
-        fs.mkdirSync(path.dirname(cachePath), { recursive: true });
-        fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
-    }
-    catch {
-        /* best-effort cache write */
-    }
-}
-/** Convert a live UsageSnapshot to its JSON-serializable cached form. */
-function serializeClaudeUsageSnapshot(snapshot) {
-    return {
-        capturedAt: snapshot.capturedAt?.toISOString() || null,
-        windows: snapshot.windows.map((window) => ({
-            key: window.key,
-            label: window.label,
-            shortLabel: window.shortLabel,
-            usedPercent: window.usedPercent,
-            resetsAt: window.resetsAt?.toISOString() || null,
-            windowMinutes: window.windowMinutes,
-        })),
-    };
-}
-/** Deserialize a cached snapshot, zeroing out windows whose reset time has passed. */
-function deserializeClaudeUsageSnapshot(snapshot, now) {
-    const capturedAt = parseDateValue(snapshot.capturedAt);
-    const windows = snapshot.windows
-        .map((window) => {
-        const w = {
-            key: window.key,
-            label: window.label,
-            shortLabel: window.shortLabel,
-            usedPercent: window.usedPercent,
-            resetsAt: parseDateValue(window.resetsAt),
-            windowMinutes: window.windowMinutes,
-        };
-        if (!isCachedUsageWindowFresh(w, capturedAt, now)) {
-            w.usedPercent = 0;
-        }
-        return w;
-    });
-    if (windows.length === 0) {
-        return null;
-    }
-    return {
-        source: 'last_seen',
-        sourceLabel: CACHED_CLAUDE_USAGE_SOURCE_LABEL,
-        capturedAt,
-        windows,
-    };
-}
-/** Check whether a cached usage window is still relevant (not expired or reset). */
-function isCachedUsageWindowFresh(window, capturedAt, now) {
-    if (window.resetsAt && window.resetsAt.getTime() <= now.getTime()) {
-        return false;
-    }
-    if (capturedAt && window.windowMinutes !== null) {
-        const expiresAt = capturedAt.getTime() + window.windowMinutes * 60 * 1000;
-        if (expiresAt <= now.getTime()) {
-            return false;
-        }
-    }
-    return true;
-}
-/** Obtain a valid access token, refreshing if expired. */
-async function getClaudeAccessToken(oauth) {
-    const accessToken = oauth.accessToken?.trim();
-    if (!accessToken) {
-        return null;
-    }
-    const expiresAt = oauth.expiresAt ?? null;
-    if (expiresAt === null || Date.now() + CLAUDE_REFRESH_LEEWAY_MS < expiresAt) {
-        return accessToken;
-    }
-    if (!oauth.refreshToken) {
-        return null;
-    }
-    const refreshed = await refreshClaudeToken(oauth);
-    return refreshed?.accessToken?.trim() || null;
-}
-/** Refresh an expired Claude OAuth access token using the refresh token. */
-async function refreshClaudeToken(oauth) {
-    const response = await fetch(CLAUDE_TOKEN_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            grant_type: 'refresh_token',
-            refresh_token: oauth.refreshToken,
-            client_id: CLAUDE_CLIENT_ID,
-            scope: (oauth.scopes?.length ? oauth.scopes : CLAUDE_SCOPES).join(' '),
-        }),
-        signal: AbortSignal.timeout(15000),
-    });
-    if (!response.ok) {
-        return null;
-    }
-    const data = await response.json();
-    if (!data.access_token || !data.expires_in) {
-        return null;
-    }
-    return {
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token || oauth.refreshToken || null,
-        expiresAt: Date.now() + data.expires_in * 1000,
-        scopes: data.scope ? data.scope.split(/\s+/).filter(Boolean) : (oauth.scopes || CLAUDE_SCOPES),
-    };
-}
-/**
- * Check whether the Claude OAuth credentials for a given home are usable.
- * Attempts a token refresh if the access token is expired.
- * Returns true only when a valid access token can be obtained.
- */
-export async function isClaudeAuthValid(home) {
-    const oauth = await loadClaudeOauth(home);
-    if (!oauth)
-        return false;
-    const token = await getClaudeAccessToken(oauth);
-    return token !== null;
-}
-/** Build a User-Agent string for Claude API requests. */
-function getClaudeUserAgent(cliVersion) {
-    return cliVersion ? `claude-code/${cliVersion}` : 'claude-code';
-}
-/** Map an HTTP status code to a user-facing error message. */
-function formatClaudeUsageError(status) {
-    if (status === 429) {
-        return 'Usage data unavailable right now.';
-    }
-    return 'Could not load usage data right now.';
-}
-/** Clamp a numeric value to 0..100, returning null for non-finite values. */
-function normalizePercent(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return null;
-    }
-    return Math.max(0, Math.min(100, value));
-}
-/** Validate and return a positive window duration, or null. */
-function normalizeWindowMinutes(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-        return null;
-    }
-    return value;
-}
-/** Infer the window duration in minutes from a well-known window key. */
-function inferWindowMinutes(key) {
-    switch (key) {
-        case 'session':
-            return 300;
-        case 'week':
-        case 'sonnet_week':
-            return 10080;
-    }
-}
-/** Parse a date value from a number (epoch seconds or ms) or ISO string. */
-function parseDateValue(value) {
-    if (value === null || value === undefined || value === '') {
-        return null;
-    }
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return new Date(value < 1e12 ? value * 1000 : value);
-    }
-    if (typeof value === 'string') {
-        const numeric = Number(value);
-        if (!Number.isNaN(numeric)) {
-            return parseDateValue(numeric);
-        }
-        const date = new Date(value);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    return null;
-}
-/** Trim and return a string, or null if empty/non-string. */
-function normalizeString(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    return trimmed || null;
-}
-/** Render a full-width usage bar for detailed views. */
-function renderUsageBar(usedPercent) {
-    return renderBar(usedPercent, USAGE_BAR_LEN);
-}
-/** Render a compact usage bar for inline summaries. */
-function renderCompactUsageBar(usedPercent) {
-    return renderBar(usedPercent, COMPACT_BAR_LEN, usedPercent > 0 ? 1 : 0);
-}
-/** Render a colored block-character progress bar. */
-function renderBar(usedPercent, length, minimumVisible = 0) {
-    const rounded = Math.round((usedPercent / 100) * length);
-    const filled = Math.max(minimumVisible, Math.max(0, Math.min(length, rounded)));
-    const color = getUsageColor(usedPercent);
-    return color(FULL.repeat(filled)) + chalk.dim(EMPTY.repeat(length - filled));
-}
-/** Apply the appropriate color to a text string based on usage percentage. */
-function colorUsage(text, usedPercent) {
-    return getUsageColor(usedPercent)(text);
-}
-/** Return a chalk color function based on the usage percentage threshold. */
-function getUsageColor(usedPercent) {
-    if (usedPercent >= 100)
-        return chalk.red;
-    if (usedPercent >= 80)
-        return chalk.yellow;
-    return chalk.cyan;
-}
-/** Format a percentage value with at most one decimal place. */
-function formatPercent(value) {
-    const rounded = Math.round(value * 10) / 10;
-    return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
-}
-/** Format a reset timestamp as a human-readable relative or absolute time. */
-function formatResetAt(date) {
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const now = new Date();
-    const isWithinDay = (date.getTime() - now.getTime()) / 3600000 <= 24;
-    const minutes = date.getMinutes();
-    if (isWithinDay) {
-        return `${date.toLocaleTimeString('en-US', {
-            hour: 'numeric',
-            minute: minutes === 0 ? undefined : '2-digit',
-            hour12: true,
-        })} (${timezone})`;
-    }
-    const options = {
-        month: 'short',
-        day: 'numeric',
-        hour: 'numeric',
-        minute: minutes === 0 ? undefined : '2-digit',
-        hour12: true,
-    };
-    if (date.getFullYear() !== now.getFullYear()) {
-        options.year = 'numeric';
-    }
-    return `${date.toLocaleString('en-US', options)} (${timezone})`;
-}
-/** Safe wrapper around fs.realpathSync that returns null on error. */
-function safeRealpathSync(filePath) {
-    try {
-        return fs.realpathSync(filePath);
-    }
-    catch {
-        return null;
-    }
-}
-/** Safe wrapper around fs.statSync that returns null on error. */
-function safeStatSync(filePath) {
-    try {
-        return fs.statSync(filePath);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=usage.js.map