@trillboards/cli 0.1.0

package/dist/commands/login.js

@@ -0,0 +1,68 @@
+import * as readline from 'node:readline';
+import { BaseCommand } from '../base-command.js';
+import { updateConfig } from '../config.js';
+import { TrillboardsApiError, apiRequest } from '../http.js';
+export default class Login extends BaseCommand {
+    static description = 'Authenticate with the Trillboards API';
+    static examples = [
+        '<%= config.bin %> login',
+        'TRILLBOARDS_API_KEY=trb_partner_xxx <%= config.bin %> login',
+    ];
+    async run() {
+        const { flags } = await this.parse(Login);
+        this.setParsedFlags(flags);
+        let apiKey = this.getApiKey();
+        if (!apiKey) {
+            apiKey = await this.promptForKey();
+        }
+        if (!apiKey) {
+            this.error('No API key provided. Set TRILLBOARDS_API_KEY or pass --api-key.', { exit: 1 });
+        }
+        // Validate the key
+        this.log('Validating API key...');
+        const baseUrl = this.getBaseUrl();
+        try {
+            await apiRequest('GET', '/v1/partner/ping/auth', { apiKey, baseUrl });
+        }
+        catch (error) {
+            if (error instanceof TrillboardsApiError && error.statusCode === 401) {
+                this.error('Invalid API key. Check your key and try again.', { exit: 1 });
+            }
+            throw error;
+        }
+        this.log('API key is valid.');
+        // Fetch partner info
+        let partnerName = 'Unknown';
+        try {
+            const info = (await apiRequest('GET', '/v1/partner/info', { apiKey, baseUrl }));
+            partnerName = info.partner_name || info.name || 'Unknown';
+        }
+        catch {
+            // Non-fatal — we still save the key
+            this.warn('Could not fetch partner info, but key is valid.');
+        }
+        // Save to config
+        updateConfig({
+            api_key: apiKey,
+            base_url: baseUrl,
+            partner_name: partnerName,
+        });
+        this.log(`Logged in as ${partnerName}. Config saved to ~/.trillboards/config.json`);
+    }
+    promptForKey() {
+        // In non-interactive mode, return empty
+        if (!process.stdin.isTTY) {
+            return Promise.resolve('');
+        }
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stderr,
+            });
+            rl.question('Enter your API key: ', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+}

package/dist/commands/logs/tail.d.ts

@@ -0,0 +1,47 @@
+import { BaseCommand } from '../../base-command.js';
+export default class LogsTail extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        events: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private abortController?;
+    private reconnectAttempts;
+    private shuttingDown;
+    run(): Promise<void>;
+    /**
+     * Check a status_code against a list of parsed patterns.
+     * Patterns:
+     *   "4xx" -> match 400-499
+     *   "5xx" -> match 500-599
+     *   "404" -> match exactly 404
+     */
+    static matchesStatus(statusCode: number | undefined, patterns: Array<{
+        exact?: number;
+        rangeStart?: number;
+    }>): boolean;
+    /**
+     * Parse a status filter string like "4xx,5xx,200" into lookup patterns.
+     */
+    static parseStatusPatterns(raw: string): Array<{
+        exact?: number;
+        rangeStart?: number;
+    }>;
+    static sleep(ms: number): Promise<void>;
+    /**
+     * Parse one or more SSE `event:` + `data:` blocks out of a raw buffer.
+     * Returns the list of complete envelopes and the remaining unparsed tail.
+     */
+    static parseSseBuffer(buffer: string): {
+        events: Array<{
+            event?: string;
+            data: string;
+            id?: string;
+        }>;
+        remainder: string;
+    };
+    private streamOnce;
+    private handleSseEvent;
+    private renderEvent;
+}

package/dist/commands/logs/tail.js

@@ -0,0 +1,240 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { colorize } from '../../format-helpers.js';
+function maxReconnectAttempts() {
+    const raw = process.env.TRILLBOARDS_CLI_MAX_RECONNECTS;
+    if (raw === undefined || raw === '')
+        return 10;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) ? n : 10;
+}
+function reconnectDelayMs() {
+    const raw = process.env.TRILLBOARDS_CLI_RECONNECT_DELAY_MS;
+    if (raw === undefined || raw === '')
+        return 3000;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) ? n : 3000;
+}
+export default class LogsTail extends BaseCommand {
+    static description = 'Tail real-time request logs via server-sent events';
+    static examples = [
+        '<%= config.bin %> logs tail',
+        '<%= config.bin %> logs tail --events error.occurred',
+        '<%= config.bin %> logs tail --status 4xx,5xx',
+        '<%= config.bin %> logs tail --events request.logged,error.occurred --status 5xx',
+    ];
+    static flags = {
+        events: Flags.string({
+            default: 'request.logged,error.occurred',
+            description: 'Comma-separated SSE event types to subscribe to',
+        }),
+        status: Flags.string({
+            description: 'Filter by status code pattern (e.g. "4xx", "5xx", "4xx,5xx", "404")',
+        }),
+    };
+    abortController;
+    reconnectAttempts = 0;
+    shuttingDown = false;
+    async run() {
+        const { flags } = await this.parse(LogsTail);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const events = flags.events || 'request.logged,error.occurred';
+        const statusPatterns = flags.status ? LogsTail.parseStatusPatterns(flags.status) : undefined;
+        // Graceful Ctrl+C
+        const cleanup = () => {
+            this.shuttingDown = true;
+            if (this.abortController)
+                this.abortController.abort();
+            this.log('\nStopped tailing logs.');
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        this.log(colorize(`Tailing logs (events: ${events})`, 'dim'));
+        if (statusPatterns) {
+            this.log(colorize(`Status filter: ${flags.status}`, 'dim'));
+        }
+        this.log(colorize('Press Ctrl+C to stop', 'dim'));
+        this.log('');
+        while (!this.shuttingDown) {
+            try {
+                await this.streamOnce(apiKey, baseUrl, events, statusPatterns);
+                // Stream ended without throwing (server closed it) — attempt reconnect.
+            }
+            catch (error) {
+                if (this.shuttingDown)
+                    return;
+                const msg = error instanceof Error ? error.message : String(error);
+                this.log(colorize(`Stream error: ${msg}`, 'red'));
+            }
+            if (this.shuttingDown)
+                return;
+            const maxAttempts = maxReconnectAttempts();
+            this.reconnectAttempts += 1;
+            if (this.reconnectAttempts > maxAttempts) {
+                this.error(`Gave up after ${maxAttempts} reconnect attempts.`, { exit: 1 });
+            }
+            const delayMs = reconnectDelayMs();
+            this.log(colorize(`Reconnecting (${this.reconnectAttempts}/${maxAttempts}) in ${delayMs / 1000}s...`, 'yellow'));
+            if (delayMs > 0)
+                await LogsTail.sleep(delayMs);
+        }
+    }
+    /**
+     * Check a status_code against a list of parsed patterns.
+     * Patterns:
+     *   "4xx" -> match 400-499
+     *   "5xx" -> match 500-599
+     *   "404" -> match exactly 404
+     */
+    static matchesStatus(statusCode, patterns) {
+        if (statusCode === undefined)
+            return false;
+        for (const p of patterns) {
+            if (p.exact !== undefined && p.exact === statusCode)
+                return true;
+            if (p.rangeStart !== undefined && statusCode >= p.rangeStart && statusCode < p.rangeStart + 100) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Parse a status filter string like "4xx,5xx,200" into lookup patterns.
+     */
+    static parseStatusPatterns(raw) {
+        return raw.split(',').map((s) => s.trim()).filter(Boolean).map((token) => {
+            const m = /^(\d)xx$/i.exec(token);
+            if (m)
+                return { rangeStart: Number(m[1]) * 100 };
+            const n = Number(token);
+            if (!Number.isNaN(n) && n >= 100 && n < 1000)
+                return { exact: n };
+            return {};
+        }).filter((p) => p.exact !== undefined || p.rangeStart !== undefined);
+    }
+    static sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    /**
+     * Parse one or more SSE `event:` + `data:` blocks out of a raw buffer.
+     * Returns the list of complete envelopes and the remaining unparsed tail.
+     */
+    static parseSseBuffer(buffer) {
+        // SSE messages are separated by `\n\n`. Handle `\r\n\r\n` defensively.
+        const normalized = buffer.replace(/\r\n/g, '\n');
+        const parts = normalized.split('\n\n');
+        const remainder = parts.pop() ?? '';
+        const events = [];
+        for (const chunk of parts) {
+            if (!chunk.trim())
+                continue;
+            // Comments: lines starting with ':' (heartbeats). Skip entirely.
+            const lines = chunk.split('\n').filter((l) => l && !l.startsWith(':'));
+            if (lines.length === 0)
+                continue;
+            let eventType;
+            let id;
+            const dataLines = [];
+            for (const line of lines) {
+                if (line.startsWith('event:'))
+                    eventType = line.slice(6).trim();
+                else if (line.startsWith('id:'))
+                    id = line.slice(3).trim();
+                else if (line.startsWith('data:'))
+                    dataLines.push(line.slice(5).trim());
+            }
+            if (dataLines.length > 0) {
+                events.push({ data: dataLines.join('\n'), event: eventType, id });
+            }
+        }
+        return { events, remainder };
+    }
+    async streamOnce(apiKey, baseUrl, events, statusPatterns) {
+        const url = new URL('/v1/partner/events/stream', baseUrl);
+        url.searchParams.set('events', events);
+        this.abortController = new AbortController();
+        const response = await fetch(url.toString(), {
+            headers: {
+                'Accept': 'text/event-stream',
+                'Authorization': `Bearer ${apiKey}`,
+                'User-Agent': 'trillboards-cli',
+                'X-Trillboards-Client-Type': 'agent',
+            },
+            signal: this.abortController.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Server returned ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('Server returned an empty body');
+        }
+        // Successful connect — reset reconnect counter.
+        this.reconnectAttempts = 0;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        try {
+            while (!this.shuttingDown) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const { events: parsed, remainder } = LogsTail.parseSseBuffer(buffer);
+                buffer = remainder;
+                for (const envelope of parsed) {
+                    this.handleSseEvent(envelope, statusPatterns);
+                }
+            }
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    handleSseEvent(envelope, statusPatterns) {
+        // Skip server-side keepalives and the initial "connected" envelope
+        if (!envelope.event || envelope.event === 'connected' || envelope.event === 'disconnected') {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(envelope.data);
+        }
+        catch {
+            // Malformed line — skip rather than crash the stream
+            return;
+        }
+        const payload = (parsed.data || parsed);
+        if (statusPatterns && !LogsTail.matchesStatus(payload.status_code, statusPatterns)) {
+            return;
+        }
+        this.renderEvent(envelope.event, payload);
+    }
+    renderEvent(eventType, payload) {
+        const status = payload.status_code ?? 0;
+        const color = status >= 500 ? 'red' : status >= 400 ? 'yellow' : 'green';
+        const timestamp = payload.timestamp ?? new Date().toISOString();
+        const method = (payload.method ?? '---').padEnd(6);
+        const path = payload.path ?? '-';
+        const statusStr = colorize(String(status || '---').padEnd(3), color);
+        const duration = payload.duration_ms !== undefined ? `${payload.duration_ms}ms` : '';
+        const requestId = payload.request_id ? colorize(payload.request_id, 'dim') : '';
+        const agent = payload.is_agent && payload.agent_name ? colorize(` [${payload.agent_name}]`, 'dim') : '';
+        const errorTag = payload.error_code ? colorize(` (${payload.error_code})`, 'red') : '';
+        const line = `${colorize(timestamp, 'dim')}  ${statusStr}  ${method} ${path}  ${colorize(duration, 'dim')}  ${requestId}${agent}${errorTag}`;
+        this.log(line);
+        if (eventType === 'error.occurred' && payload.error_type) {
+            this.log(`  ${colorize(`error_type: ${payload.error_type}`, 'dim')}`);
+        }
+    }
+}

package/dist/commands/reconcile.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base-command.js';
+export default class Reconcile extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        period: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/reconcile.js

@@ -0,0 +1,58 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../base-command.js';
+import { colorize, formatCount, formatCurrency, formatPercent } from '../format-helpers.js';
+import { apiRequest } from '../http.js';
+export default class Reconcile extends BaseCommand {
+    static description = 'Revenue reconciliation — compare our numbers with partner reports';
+    static examples = [
+        '<%= config.bin %> reconcile',
+        '<%= config.bin %> reconcile --period 7d',
+        '<%= config.bin %> reconcile --format json',
+    ];
+    static flags = {
+        period: Flags.string({
+            default: '30d',
+            description: 'Time period for reconciliation (e.g. 7d, 30d)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Reconcile);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        const period = flags.period ?? '30d';
+        const data = await apiRequest('GET', '/v1/partner/fleet/analytics', {
+            apiKey,
+            baseUrl,
+            params: { period },
+        });
+        if (format === 'json') {
+            this.output({
+                fill_rate: data.fill_rate ?? 0,
+                impressions: data.impressions ?? 0,
+                period,
+                revenue: data.revenue ?? 0,
+            });
+            return;
+        }
+        this.log(colorize('Revenue Reconciliation', 'bold'));
+        this.log('');
+        const impressions = data.impressions ?? 0;
+        const revenue = data.revenue ?? 0;
+        const fillRate = data.fill_rate ?? 0;
+        this.log(`Our Impressions (${period}):  ${formatCount(impressions)}`);
+        this.log(`Our Revenue (${period}):      ${formatCurrency(revenue)}`);
+        this.log(`Fill Rate:              ${formatPercent(fillRate)}`);
+        this.log('');
+        this.log(colorize('To compare with partner reports:', 'bold'));
+        this.log('  1. Log in to your demand partner dashboard');
+        this.log(`  2. Pull the same date range (${period})`);
+        this.log('  3. Compare impression counts (threshold: +/-5%)');
+        this.log('');
+        this.log(`Run: trillboards api GET /v1/partner/fleet/analytics --format json`);
+    }
+}

package/dist/commands/sandbox/create.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../../base-command.js';
+export default class SandboxCreate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/sandbox/create.js

@@ -0,0 +1,35 @@
+import { BaseCommand } from '../../base-command.js';
+import { colorize } from '../../format-helpers.js';
+import { apiRequest } from '../../http.js';
+export default class SandboxCreate extends BaseCommand {
+    static description = 'Create a sandbox test screen';
+    static examples = [
+        '<%= config.bin %> sandbox create',
+        '<%= config.bin %> sandbox create --format json',
+    ];
+    async run() {
+        const { flags } = await this.parse(SandboxCreate);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        const result = await apiRequest('POST', '/v1/partner/sandbox/screen', { apiKey, baseUrl });
+        if (format === 'json') {
+            this.output(result);
+            return;
+        }
+        this.log(colorize('Sandbox screen created!', 'green'));
+        this.log('');
+        this.log(`Screen ID:  ${result.screen_id ?? 'N/A'}`);
+        this.log(`Device ID:  ${result.device_id ?? 'N/A'}`);
+        this.log(`Name:       ${result.name ?? 'N/A'}`);
+        this.log(`Status:     ${result.status ?? 'N/A'}`);
+        this.log('');
+        this.log('Next steps:');
+        this.log(`  Emit an event:  trillboards sandbox emit impression.recorded`);
+        this.log(`  Check status:   trillboards sandbox status`);
+    }
+}

package/dist/commands/sandbox/emit.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command.js';
+export default class SandboxEmit extends BaseCommand {
+    static args: {
+        event_type: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        data: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/sandbox/emit.js

@@ -0,0 +1,57 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base-command.js';
+import { colorize } from '../../format-helpers.js';
+import { apiRequest } from '../../http.js';
+export default class SandboxEmit extends BaseCommand {
+    static args = {
+        event_type: Args.string({
+            description: 'Event type to emit (e.g. impression.recorded, heartbeat)',
+            required: true,
+        }),
+    };
+    static description = 'Emit a test event in the sandbox';
+    static examples = [
+        '<%= config.bin %> sandbox emit impression.recorded',
+        '<%= config.bin %> sandbox emit heartbeat',
+        '<%= config.bin %> sandbox emit impression.recorded --data \'{"cpm": 3.50}\'',
+    ];
+    static flags = {
+        data: Flags.string({ char: 'd', description: 'Additional event data (JSON string)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SandboxEmit);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        const eventType = args.event_type;
+        let extraData = {};
+        if (flags.data) {
+            try {
+                extraData = JSON.parse(flags.data);
+            }
+            catch {
+                this.error('Invalid JSON in --data flag.', { exit: 1 });
+            }
+        }
+        const body = {
+            event_type: eventType,
+            ...extraData,
+        };
+        const result = await apiRequest('POST', '/v1/partner/sandbox/event', { apiKey, baseUrl, body });
+        if (format === 'json') {
+            this.output(result);
+            return;
+        }
+        this.log(colorize(`Event emitted: ${eventType}`, 'green'));
+        if (result.event_id) {
+            this.log(`Event ID: ${result.event_id}`);
+        }
+        if (result.message) {
+            this.log(`${result.message}`);
+        }
+    }
+}

package/dist/commands/sandbox/reset.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../../base-command.js';
+export default class SandboxReset extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/sandbox/reset.js

@@ -0,0 +1,34 @@
+import { BaseCommand } from '../../base-command.js';
+import { colorize } from '../../format-helpers.js';
+import { apiRequest } from '../../http.js';
+export default class SandboxReset extends BaseCommand {
+    static description = 'Reset the sandbox — delete all test screens and events';
+    static examples = [
+        '<%= config.bin %> sandbox reset',
+        '<%= config.bin %> sandbox reset --format json',
+    ];
+    async run() {
+        const { flags } = await this.parse(SandboxReset);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        const result = await apiRequest('POST', '/v1/partner/sandbox/reset', { apiKey, baseUrl });
+        if (format === 'json') {
+            this.output(result);
+            return;
+        }
+        this.log(colorize('Sandbox reset complete.', 'green'));
+        if (result.screens_deleted != null) {
+            this.log(`Screens deleted: ${result.screens_deleted}`);
+        }
+        if (result.events_deleted != null) {
+            this.log(`Events deleted: ${result.events_deleted}`);
+        }
+        this.log('');
+        this.log('Start fresh: trillboards sandbox create');
+    }
+}

package/dist/commands/sandbox/status.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '../../base-command.js';
+export default class SandboxStatus extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/sandbox/status.js

@@ -0,0 +1,58 @@
+import { BaseCommand } from '../../base-command.js';
+import { colorize, colorStatus, formatCount } from '../../format-helpers.js';
+import { apiRequest } from '../../http.js';
+export default class SandboxStatus extends BaseCommand {
+    static description = 'Show sandbox status — screens and recent events';
+    static examples = [
+        '<%= config.bin %> sandbox status',
+        '<%= config.bin %> sandbox status --format json',
+    ];
+    async run() {
+        const { flags } = await this.parse(SandboxStatus);
+        this.setParsedFlags(flags);
+        const apiKey = this.getApiKey();
+        if (!apiKey) {
+            this.error('Not logged in. Run: trillboards login', { exit: 1 });
+        }
+        const baseUrl = this.getBaseUrl();
+        const format = this.getFormat();
+        const result = await apiRequest('GET', '/v1/partner/sandbox/status', { apiKey, baseUrl });
+        if (format === 'json') {
+            this.output(result);
+            return;
+        }
+        this.log(colorize('Sandbox Status', 'bold'));
+        this.log('');
+        // Screens
+        const screens = result.screens ?? [];
+        this.log(colorize(`Screens (${screens.length})`, 'bold'));
+        if (screens.length === 0) {
+            this.log('  No sandbox screens. Run: trillboards sandbox create');
+        }
+        else {
+            for (const screen of screens) {
+                const name = screen.name ?? screen.screen_id ?? 'Unknown';
+                const status = screen.status ?? 'unknown';
+                this.log(`  ${name}  ${colorStatus(status)}`);
+            }
+        }
+        this.log('');
+        // Recent events
+        const events = result.events ?? [];
+        this.log(colorize(`Recent Events (${events.length})`, 'bold'));
+        if (events.length === 0) {
+            this.log('  No events yet. Run: trillboards sandbox emit impression.recorded');
+        }
+        else {
+            for (const event of events.slice(0, 20)) {
+                const type = event.event_type ?? 'unknown';
+                const time = event.timestamp ?? '';
+                const id = event.event_id ?? '';
+                this.log(`  ${type.padEnd(24)} ${time.padEnd(24)} ${id}`);
+            }
+            if (events.length > 20) {
+                this.log(colorize(`  ... and ${formatCount(events.length - 20)} more`, 'dim'));
+            }
+        }
+    }
+}

package/dist/commands/screens/watch.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command.js';
+export default class ScreensWatch extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private fetchData;
+    private filterAndSort;
+    private renderTable;
+}