@leo000001/opencode-quota-sidebar 3.0.10 → 4.0.2

package/dist/cli.js

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { createOpencodeClient } from '@opencode-ai/sdk/client';
+import { cliCurrentLabel, renderCliDashboard, renderCliHistoryDashboard, } from './cli_render.js';
+import { createQuotaRuntime } from './quota.js';
+import { createQuotaService } from './quota_service.js';
+import { sinceFromLast } from './period.js';
+import { authFilePath, loadConfig, loadState, 
+// reused for CLI-local config layering
+quotaConfigPaths, resolveOpencodeDataDir, stateFilePath, } from './storage.js';
+import { filterHistoryProvidersForDisplay, filterUsageProvidersForDisplay, listCurrentProviderIDs, } from './provider_catalog.js';
+import { createUsageService } from './usage_service.js';
+const DEFAULT_OPENCODE_BASE_URL = 'http://localhost:4096';
+const CLI_SERVER_TIMEOUT_MS = 10_000;
+const HELP_TEXT = `opencode-quota
+
+Usage:
+  opencode-quota day
+  opencode-quota day 7
+  opencode-quota day --since 2026-04-01
+  opencode-quota week
+  opencode-quota week 8
+  opencode-quota week --since 2026-04-01
+  opencode-quota month
+  opencode-quota month 6
+  opencode-quota month --since 2026-01
+
+Notes:
+  day with no extra args means the current natural day
+  week with no extra args means the current natural week starting Monday
+  month with no extra args means the current natural month
+  positional integers map to last=<N>
+  --since accepts YYYY-MM-DD for day/week and YYYY-MM for month
+`;
+function isPositiveInteger(value) {
+    return /^\d+$/.test(value) && Number(value) > 0;
+}
+function validSinceForPeriod(period, value) {
+    if (period === 'month')
+        return /^\d{4}-\d{2}$/.test(value);
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+export function parseCliArgs(argv) {
+    if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+        throw new Error(HELP_TEXT);
+    }
+    const [periodArg, ...rest] = argv;
+    if (periodArg !== 'day' && periodArg !== 'week' && periodArg !== 'month') {
+        throw new Error(`Unknown period: ${periodArg}\n\n${HELP_TEXT}`);
+    }
+    let since;
+    let last;
+    const positional = [];
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === '--since') {
+            const value = rest[index + 1];
+            if (!value) {
+                throw new Error('Missing value for --since');
+            }
+            since = value.trim();
+            index += 1;
+            continue;
+        }
+        if (arg === '--last') {
+            const value = rest[index + 1];
+            if (!value || !isPositiveInteger(value)) {
+                throw new Error('--last must be a positive integer');
+            }
+            last = Number(value);
+            index += 1;
+            continue;
+        }
+        positional.push(arg);
+    }
+    if (positional.length > 1) {
+        throw new Error(`Too many positional arguments\n\n${HELP_TEXT}`);
+    }
+    if (positional.length === 1) {
+        const value = positional[0].trim();
+        if (isPositiveInteger(value)) {
+            last = Number(value);
+        }
+        else if (validSinceForPeriod(periodArg, value)) {
+            since = value;
+        }
+        else {
+            throw new Error(periodArg === 'month'
+                ? 'Expected a positive integer or YYYY-MM'
+                : 'Expected a positive integer or YYYY-MM-DD');
+        }
+    }
+    if (since && last !== undefined) {
+        throw new Error('Cannot use both since and last');
+    }
+    if (since && !validSinceForPeriod(periodArg, since)) {
+        throw new Error(periodArg === 'month'
+            ? '--since must use YYYY-MM for month'
+            : '--since must use YYYY-MM-DD for day/week');
+    }
+    return {
+        period: periodArg,
+        ...(since ? { since } : {}),
+        ...(last !== undefined ? { last } : {}),
+    };
+}
+export function cliBaseUrl() {
+    const override = process.env.OPENCODE_BASE_URL?.trim();
+    return override || DEFAULT_OPENCODE_BASE_URL;
+}
+function isDefaultBaseUrl() {
+    return !process.env.OPENCODE_BASE_URL?.trim();
+}
+export function cliServerCommandCandidates(platform = process.platform) {
+    const directArgs = ['serve', '--hostname=127.0.0.1', '--port=4096'];
+    if (platform === 'win32') {
+        return [
+            { command: 'opencode.cmd', args: directArgs },
+            {
+                command: 'opencode serve --hostname=127.0.0.1 --port=4096',
+                args: [],
+                shell: true,
+            },
+            {
+                command: 'bash',
+                args: ['-lc', 'opencode serve --hostname=127.0.0.1 --port=4096'],
+            },
+        ];
+    }
+    return [{ command: 'opencode', args: directArgs }];
+}
+async function tryStartCliOpencodeServer(candidate) {
+    let proc;
+    try {
+        proc = spawn(candidate.command, candidate.args, {
+            env: process.env,
+            shell: candidate.shell ?? false,
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        const code = error.code;
+        throw {
+            error,
+            output: '',
+            recoverable: code === 'ENOENT' || code === 'EINVAL',
+        };
+    }
+    const url = await new Promise((resolve, reject) => {
+        const id = setTimeout(() => {
+            reject(new Error(`Timeout waiting for OpenCode server to start after ${CLI_SERVER_TIMEOUT_MS}ms`));
+        }, CLI_SERVER_TIMEOUT_MS);
+        let output = '';
+        let settled = false;
+        const inspect = (chunk) => {
+            output += chunk.toString();
+            const lines = output.split('\n');
+            for (const line of lines) {
+                if (!line.startsWith('opencode server listening'))
+                    continue;
+                const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
+                if (!match)
+                    continue;
+                clearTimeout(id);
+                settled = true;
+                resolve(match[1]);
+                return;
+            }
+        };
+        proc.stdout?.on('data', inspect);
+        proc.stderr?.on('data', inspect);
+        proc.on('error', (error) => {
+            clearTimeout(id);
+            const code = error.code;
+            reject({
+                error,
+                output,
+                recoverable: code === 'ENOENT' || code === 'EINVAL',
+            });
+        });
+        proc.on('exit', (code) => {
+            if (settled)
+                return;
+            clearTimeout(id);
+            let message = `OpenCode server exited with code ${code}`;
+            if (output.trim())
+                message += `\n${output}`;
+            const recoverable = /not recognized as an internal or external command/i.test(output) ||
+                /command not found/i.test(output);
+            reject({ error: new Error(message), output, recoverable });
+        });
+    });
+    return {
+        url,
+        close: () => proc.kill(),
+    };
+}
+async function startCliOpencodeServer() {
+    const candidates = cliServerCommandCandidates();
+    let lastError;
+    for (const candidate of candidates) {
+        try {
+            return await tryStartCliOpencodeServer(candidate);
+        }
+        catch (failure) {
+            lastError = failure;
+            const recoverable = typeof failure === 'object' &&
+                failure !== null &&
+                'recoverable' in failure &&
+                failure.recoverable === true;
+            if (!recoverable) {
+                const error = typeof failure === 'object' && failure !== null && 'error' in failure
+                    ? failure.error
+                    : failure;
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+    }
+    const error = typeof lastError === 'object' && lastError !== null && 'error' in lastError
+        ? lastError.error
+        : lastError;
+    throw error instanceof Error
+        ? error
+        : new Error('Failed to start OpenCode server');
+}
+async function resolvePathInfo(directory) {
+    const connect = async (baseUrl) => {
+        const client = createOpencodeClient({ directory, baseUrl });
+        const response = await client.path.get({
+            query: { directory },
+            throwOnError: true,
+        });
+        const data = response.data;
+        return {
+            client,
+            worktree: data.worktree || directory,
+            directory: data.directory || directory,
+            close: () => { },
+        };
+    };
+    try {
+        return await connect(cliBaseUrl());
+    }
+    catch (error) {
+        if (!isDefaultBaseUrl()) {
+            throw new Error(`Failed to connect to OpenCode API at ${cliBaseUrl()}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const server = await startCliOpencodeServer();
+        const client = createOpencodeClient({
+            directory,
+            baseUrl: server.url,
+        });
+        const response = await client.path.get({
+            query: { directory },
+            throwOnError: true,
+        });
+        const data = response.data;
+        return {
+            client,
+            worktree: data.worktree || directory,
+            directory: data.directory || directory,
+            close: () => server.close(),
+        };
+    }
+}
+export async function runCli(argv) {
+    const command = parseCliArgs(argv);
+    const cwd = process.cwd();
+    const connection = await resolvePathInfo(cwd);
+    try {
+        const { client, worktree, directory } = connection;
+        const config = await loadConfig(quotaConfigPaths(worktree, directory));
+        const dataDir = resolveOpencodeDataDir();
+        const statePath = stateFilePath(dataDir);
+        const authPath = authFilePath(dataDir);
+        const state = await loadState(statePath);
+        const quotaService = createQuotaService({
+            quotaRuntime: createQuotaRuntime(),
+            config,
+            state,
+            authPath,
+            client: client,
+            directory,
+            scheduleSave: () => { },
+        });
+        const usageService = createUsageService({
+            state,
+            config,
+            statePath,
+            client: client,
+            directory,
+            persistence: {
+                markDirty: () => { },
+                scheduleSave: () => { },
+                flushSave: async () => { },
+            },
+            descendantsResolver: {
+                listDescendantSessionIDs: async () => [],
+            },
+        });
+        const quotas = await quotaService.getQuotaSnapshots([], {
+            allowDefault: true,
+        });
+        const allowedProviderIDs = await listCurrentProviderIDs({
+            client,
+            directory,
+        }).catch(() => new Set());
+        if (command.since || command.last !== undefined) {
+            const resolvedSince = command.since || sinceFromLast(command.period, command.last);
+            const historyRaw = await usageService.summarizeHistoryUsage(command.period, resolvedSince);
+            const history = filterHistoryProvidersForDisplay(historyRaw, allowedProviderIDs);
+            return renderCliHistoryDashboard({
+                result: history,
+                quotas,
+                width: 80,
+                showCost: config.sidebar.showCost,
+            });
+        }
+        const usageRaw = await usageService.summarizeForTool(command.period, '', false);
+        const usage = filterUsageProvidersForDisplay(usageRaw, allowedProviderIDs);
+        return renderCliDashboard({
+            label: cliCurrentLabel(command.period),
+            usage,
+            quotas,
+            width: 80,
+            showCost: config.sidebar.showCost,
+        });
+    }
+    finally {
+        connection.close();
+    }
+}
+export function cliExitCodeForError(message) {
+    return message === HELP_TEXT ? 0 : 1;
+}
+async function main() {
+    try {
+        const output = await runCli(process.argv.slice(2));
+        process.stdout.write(`${output}\n`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const exitCode = cliExitCodeForError(message);
+        const stream = exitCode === 0 ? process.stdout : process.stderr;
+        stream.write(`${message}\n`);
+        process.exitCode = exitCode;
+    }
+}
+if (process.argv[1] &&
+    path.resolve(fileURLToPath(import.meta.url)) === path.resolve(process.argv[1])) {
+    void main();
+}

package/dist/cli_render.d.ts

@@ -0,0 +1,17 @@
+import type { QuotaSnapshot } from './types.js';
+import { type UsageSummary } from './usage.js';
+import type { HistoryUsageResult } from './usage_service.js';
+export declare function renderCliDashboard(input: {
+    label: string;
+    usage: UsageSummary;
+    quotas: QuotaSnapshot[];
+    width?: number;
+    showCost?: boolean;
+}): string;
+export declare function renderCliHistoryDashboard(input: {
+    result: HistoryUsageResult;
+    quotas: QuotaSnapshot[];
+    width?: number;
+    showCost?: boolean;
+}): string;
+export declare function cliCurrentLabel(period: 'day' | 'week' | 'month'): "Today" | "This Week" | "This Month";

package/dist/cli_render.js

@@ -0,0 +1,292 @@
+import { canonicalProviderID, collapseQuotaSnapshots, quotaDisplayLabel, } from './quota_render.js';
+import { getCacheCoverageMetrics, getProviderCacheCoverageMetrics, } from './usage.js';
+function shortNumber(value, decimals = 1) {
+    if (!Number.isFinite(value) || value < 0)
+        return '0';
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(decimals)}m`;
+    if (value >= 1000) {
+        const k = value / 1000;
+        if (Number(k.toFixed(decimals)) >= 1000) {
+            return `${(value / 1_000_000).toFixed(decimals)}m`;
+        }
+        return `${k.toFixed(decimals)}k`;
+    }
+    return `${Math.round(value)}`;
+}
+function formatCurrency(value, currency) {
+    const safe = Number.isFinite(value) ? value : 0;
+    const prefix = typeof currency === 'string' && currency ? currency : '$';
+    if (safe === 0)
+        return `${prefix}0.00`;
+    if (safe < 10 && safe > -10)
+        return `${safe < 0 ? '-' : ''}${prefix}${Math.abs(safe).toFixed(2)}`;
+    const rounded = Math.abs(safe).toFixed(1).replace(/\.0$/, '');
+    return `${safe < 0 ? '-' : ''}${prefix}${rounded}`;
+}
+function formatApiCost(value) {
+    return formatCurrency(value, '$');
+}
+function formatPercent(value, decimals = 1) {
+    const safe = Number.isFinite(value) && value >= 0 ? value : 0;
+    const pct = (safe * 100).toFixed(decimals);
+    return `${pct.replace(/\.0+$/, '').replace(/(\.\d*[1-9])0+$/, '$1')}%`;
+}
+function compactCountdown(iso) {
+    if (!iso)
+        return 'n/a';
+    const timestamp = Date.parse(iso);
+    if (Number.isNaN(timestamp))
+        return 'n/a';
+    const remainingMs = timestamp - Date.now();
+    if (!Number.isFinite(remainingMs))
+        return 'n/a';
+    if (remainingMs <= 0)
+        return '0m';
+    const totalMinutes = Math.max(1, Math.floor(remainingMs / 60_000));
+    if (totalMinutes < 60)
+        return `${totalMinutes}m`;
+    if (totalMinutes < 24 * 60) {
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        return `${hours}h${`${minutes}`.padStart(2, '0')}m`;
+    }
+    const days = Math.floor(totalMinutes / (24 * 60));
+    const hours = Math.floor((totalMinutes % (24 * 60)) / 60);
+    return `${days}D${`${hours}`.padStart(2, '0')}h`;
+}
+function gauge(value, width = 10) {
+    if (value === undefined || !Number.isFinite(value))
+        return `${'░'.repeat(width)}  n/a`;
+    const ratio = Math.max(0, Math.min(1, value / 100));
+    const filled = Math.max(value > 0 ? 1 : 0, Math.round(ratio * width));
+    return `${'█'.repeat(filled)}${'░'.repeat(width - filled)} ${`${Math.round(value)}`.padStart(3, ' ')}%`;
+}
+function formatDelta(current, previous, format) {
+    if (previous === undefined)
+        return `${format(current)} now`;
+    if (!Number.isFinite(previous) || previous < 0)
+        return `${format(current)} now`;
+    if (previous === 0)
+        return `${format(current)} now, ${current === 0 ? 'flat' : 'new'}`;
+    const delta = ((current - previous) / previous) * 100;
+    const rounded = Math.abs(delta) >= 10 ? delta.toFixed(0) : delta.toFixed(1);
+    const normalized = rounded.replace(/\.0$/, '');
+    return `${format(current)} now, ${delta > 0 ? '+' : ''}${normalized}%`;
+}
+function clip(value, width) {
+    return value.length <= width
+        ? value
+        : `${value.slice(0, Math.max(0, width - 1))}~`;
+}
+function centerLine(value, width) {
+    const clipped = clip(value, width);
+    if (clipped.length >= width)
+        return clipped;
+    const left = Math.floor((width - clipped.length) / 2);
+    const right = width - clipped.length - left;
+    return `${' '.repeat(left)}${clipped}${' '.repeat(right)}`;
+}
+function padRight(value, width) {
+    return clip(value, width).padEnd(width, ' ');
+}
+function box(title, lines, width = 78) {
+    const longestLine = lines.reduce((max, line) => Math.max(max, line.length), 0);
+    const inner = Math.max(48, width, title.length, longestLine);
+    const top = centerLine(title, inner);
+    const rule = '─'.repeat(inner);
+    const body = lines.map((line) => clip(line, inner));
+    return [top, rule, ...body, rule].join('\n');
+}
+function currentLabel(period) {
+    if (period === 'day')
+        return 'Today';
+    if (period === 'week')
+        return 'This Week';
+    return 'This Month';
+}
+function historyLabel(result) {
+    if (result.period === 'day')
+        return `Daily since ${result.since.raw}`;
+    if (result.period === 'week')
+        return `Weekly since ${result.since.raw}`;
+    return `Monthly since ${result.since.raw}`;
+}
+function quotaRows(quotas) {
+    const visible = collapseQuotaSnapshots(quotas).filter((item) => item.status === 'ok' || item.status === 'error');
+    if (visible.length === 0)
+        return ['no provider quota data available'];
+    return visible.flatMap((quota) => {
+        const label = quotaDisplayLabel(quota).padEnd(11, ' ');
+        if (quota.status === 'error') {
+            return [`${label} error${quota.note ? ` · ${quota.note}` : ''}`];
+        }
+        if (quota.windows && quota.windows.length > 0) {
+            const lines = quota.windows.map((win) => {
+                const detail = padRight(win.label || 'quota', 18);
+                if (win.showPercent === false) {
+                    return `${label}${detail} ${compactCountdown(win.resetAt)}`;
+                }
+                return `${label}${detail} [${gauge(win.remainingPercent)}] ${compactCountdown(win.resetAt)}`;
+            });
+            if (quota.balance) {
+                lines.push(`${label}${padRight('balance', 18)} ${formatCurrency(quota.balance.amount, quota.balance.currency)}`);
+            }
+            return lines;
+        }
+        if (quota.balance) {
+            return [
+                `${label}${padRight('balance', 18)} ${formatCurrency(quota.balance.amount, quota.balance.currency)}`,
+            ];
+        }
+        return [
+            `${label}[${gauge(quota.remainingPercent)}] · ${compactCountdown(quota.resetAt)}`,
+        ];
+    });
+}
+function providerRows(usage, showCost) {
+    const providers = Object.values(usage.providers).sort((a, b) => b.total - a.total);
+    if (providers.length === 0)
+        return ['no provider activity'];
+    return providers.map((provider) => {
+        const cache = getProviderCacheCoverageMetrics(provider).cachedRatio;
+        const base = `${quotaDisplayLabel({ providerID: provider.providerID, label: provider.providerID, status: 'ok', checkedAt: 0 }).padEnd(10, ' ')} ${shortNumber(provider.assistantMessages).padStart(4, ' ')} req  ${shortNumber(provider.total).padStart(7, ' ')} tok  ${(cache !== undefined ? formatPercent(cache, 0) : '-').padStart(4, ' ')} cache`;
+        const apiCost = canonicalProviderID(provider.providerID) === 'github-copilot'
+            ? '-'
+            : formatApiCost(provider.apiCost);
+        return showCost ? `${base}  ${apiCost.padStart(7, ' ')}` : base;
+    });
+}
+function cliApiCostSummary(usage) {
+    const providers = Object.values(usage.providers);
+    if (providers.length === 0)
+        return formatApiCost(usage.apiCost);
+    const hasNonCopilot = providers.some((provider) => canonicalProviderID(provider.providerID) !== 'github-copilot');
+    return hasNonCopilot ? formatApiCost(usage.apiCost) : '-';
+}
+function totalsRows(input) {
+    const left = [`Requests ${input.requests}`, `Tokens ${input.tokens}`];
+    const right = [
+        ...(input.cost ? [`Cost ${input.cost}`] : []),
+        ...(input.cache ? [`Cache ${input.cache}`] : []),
+    ];
+    const metaLeft = input.periods ? `Periods ${input.periods}` : undefined;
+    const metaRight = input.current ? `Current ${input.current}` : undefined;
+    const row1 = [left[0], left[1], ...right].join('   ');
+    const row2 = [metaLeft, metaRight].filter(Boolean).join('   ');
+    return [row1, ...(row2 ? [row2] : [])];
+}
+function trendBar(value, maxValue, width = 20) {
+    if (!Number.isFinite(value) || value <= 0 || maxValue <= 0) {
+        return '░'.repeat(width);
+    }
+    const filled = Math.max(1, Math.round((value / maxValue) * width));
+    return `${'█'.repeat(filled)}${'░'.repeat(width - filled)}`;
+}
+function trendMetricBlock(input) {
+    const visibleRows = input.rows.slice(-Math.min(8, input.rows.length));
+    const values = visibleRows.map(input.pick);
+    const maxValue = Math.max(...values, 0);
+    const currentValue = input.current ? input.pick(input.current) : 0;
+    const displayLabels = visibleRows.map((row) => `${row.range.shortLabel}${row.range.isCurrent ? '*' : ''}`);
+    const labelWidth = Math.max(8, Math.min(28, Math.max(...displayLabels.map((label) => label.length), 8)));
+    return [
+        `${input.label} ${input.format(currentValue)}`,
+        ...visibleRows.map((row, index) => {
+            const value = input.pick(row);
+            const tag = padRight(displayLabels[index], labelWidth);
+            return `  ${tag} | ${trendBar(value, maxValue)} | ${input.format(value)}`;
+        }),
+    ];
+}
+export function renderCliDashboard(input) {
+    const width = input.width ?? 78;
+    const showCost = input.showCost !== false;
+    const cache = getCacheCoverageMetrics(input.usage).cachedRatio;
+    return box(`opencode-quota · ${input.label}`, [
+        'QUOTA',
+        ...quotaRows(input.quotas),
+        '',
+        'TOTALS',
+        ...totalsRows({
+            requests: shortNumber(input.usage.assistantMessages),
+            tokens: shortNumber(input.usage.total),
+            ...(showCost ? { cost: cliApiCostSummary(input.usage) } : {}),
+            cache: cache !== undefined ? formatPercent(cache, 1) : '-',
+            periods: `${input.usage.sessionCount}`,
+        }),
+        `Input ${shortNumber(input.usage.input)}   Output ${shortNumber(input.usage.output)}`,
+        '',
+        'PROVIDERS',
+        ...providerRows(input.usage, showCost),
+    ], width);
+}
+export function renderCliHistoryDashboard(input) {
+    const width = input.width ?? 78;
+    const showCost = input.showCost !== false;
+    const rows = input.result.rows;
+    const current = [...rows].reverse().find((row) => row.range.isCurrent) || rows.at(-1);
+    const currentIndex = current ? rows.indexOf(current) : -1;
+    const previous = currentIndex > 0 ? rows[currentIndex - 1] : undefined;
+    const cache = getCacheCoverageMetrics(input.result.total).cachedRatio;
+    const trendBlocks = [
+        ...trendMetricBlock({
+            label: 'Requests',
+            rows,
+            current,
+            pick: (row) => row.usage.assistantMessages,
+            format: (value) => shortNumber(value),
+        }),
+        '',
+        ...trendMetricBlock({
+            label: 'Tokens',
+            rows,
+            current,
+            pick: (row) => row.usage.total,
+            format: (value) => shortNumber(value),
+        }),
+        '',
+        ...trendMetricBlock({
+            label: 'Cache',
+            rows,
+            current,
+            pick: (row) => getCacheCoverageMetrics(row.usage).cachedRatio ?? 0,
+            format: (value) => formatPercent(value, 1),
+        }),
+        ...(showCost
+            ? [
+                '',
+                ...trendMetricBlock({
+                    label: 'Cost',
+                    rows,
+                    current,
+                    pick: (row) => row.usage.apiCost,
+                    format: (value) => formatApiCost(value),
+                }),
+            ]
+            : []),
+    ];
+    return box(`opencode-quota · ${historyLabel(input.result)}`, [
+        'QUOTA',
+        ...quotaRows(input.quotas),
+        '',
+        'TOTALS',
+        ...totalsRows({
+            requests: shortNumber(input.result.total.assistantMessages),
+            tokens: shortNumber(input.result.total.total),
+            ...(showCost ? { cost: cliApiCostSummary(input.result.total) } : {}),
+            cache: cache !== undefined ? formatPercent(cache, 1) : '-',
+            periods: `${rows.length}`,
+            current: current?.range.shortLabel || '-',
+        }),
+        '',
+        'PROVIDERS',
+        ...providerRows(input.result.total, showCost),
+        '',
+        'TREND',
+        ...trendBlocks,
+    ], width);
+}
+export function cliCurrentLabel(period) {
+    return currentLabel(period);
+}

package/dist/events.d.ts

@@ -3,7 +3,7 @@ export declare function createEventDispatcher(handlers: {
     onSessionCreated: (session: Session) => Promise<void>;
     onSessionUpdated: (session: Session) => Promise<void>;
     onSessionDeleted: (session: Session) => Promise<void>;
-    onTuiActivity: () => Promise<void>;
+    onTuiActivity: (sessionID?: string) => Promise<void>;
     onTuiSessionSelect: (sessionID: string) => Promise<void>;
     onMessageRemoved: (info: {
         sessionID: string;

package/dist/events.js

@@ -18,14 +18,14 @@ export function createEventDispatcher(handlers) {
         }
         if (tui.type === 'tui.prompt.append' ||
             tui.type === 'tui.command.execute') {
-            await handlers.onTuiActivity();
+            await handlers.onTuiActivity(tui.properties?.sessionID);
             return;
         }
         if (tui.type === 'tui.session.select') {
             if (typeof tui.properties?.sessionID !== 'string')
                 return;
             await handlers.onTuiSessionSelect(tui.properties.sessionID);
-            await handlers.onTuiActivity();
+            await handlers.onTuiActivity(tui.properties.sessionID);
             return;
         }
         if (event.type === 'message.removed') {