eas-cli 18.5.0 → 18.7.0

package/build/observe/fetchMetrics.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDateFlag = validateDateFlag;
+exports.fetchObserveMetricsAsync = fetchObserveMetricsAsync;
+const tslib_1 = require("tslib");
+const errors_1 = require("../commandUtils/errors");
+const generated_1 = require("../graphql/generated");
+const ObserveQuery_1 = require("../graphql/queries/ObserveQuery");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const formatMetrics_1 = require("./formatMetrics");
+const appPlatformToObservePlatform = {
+    [generated_1.AppPlatform.Android]: generated_1.AppObservePlatform.Android,
+    [generated_1.AppPlatform.Ios]: generated_1.AppObservePlatform.Ios,
+};
+function validateDateFlag(value, flagName) {
+    const parsed = new Date(value);
+    if (isNaN(parsed.getTime())) {
+        throw new errors_1.EasCommandError(`Invalid ${flagName} date: "${value}". Provide a valid ISO 8601 date (e.g. 2025-01-01).`);
+    }
+}
+async function fetchObserveMetricsAsync(graphqlClient, appId, metricNames, platforms, startTime, endTime) {
+    const queries = platforms.map(async (appPlatform) => {
+        const observePlatform = appPlatformToObservePlatform[appPlatform];
+        try {
+            const appVersions = await ObserveQuery_1.ObserveQuery.appVersionsAsync(graphqlClient, {
+                appId,
+                platform: observePlatform,
+                startTime,
+                endTime,
+                metricNames,
+            });
+            return { appPlatform, appVersions };
+        }
+        catch (error) {
+            log_1.default.warn(`Failed to fetch observe data on ${observePlatform}: ${error.message}`);
+            return null;
+        }
+    });
+    const results = await Promise.all(queries);
+    const metricsMap = new Map();
+    const buildNumbersMap = new Map();
+    const updateIdsMap = new Map();
+    const totalEventCounts = new Map();
+    for (const result of results) {
+        if (!result) {
+            continue;
+        }
+        const { appPlatform, appVersions } = result;
+        for (const version of appVersions) {
+            const key = (0, formatMetrics_1.makeMetricsKey)(version.appVersion, appPlatform);
+            if (!metricsMap.has(key)) {
+                metricsMap.set(key, new Map());
+            }
+            if (!buildNumbersMap.has(key)) {
+                buildNumbersMap.set(key, version.buildNumbers.map(bn => bn.appBuildNumber));
+            }
+            if (!updateIdsMap.has(key)) {
+                updateIdsMap.set(key, version.updates.map(u => u.appUpdateId));
+            }
+            for (const metric of version.metrics) {
+                const values = {
+                    min: metric.statistics.min,
+                    max: metric.statistics.max,
+                    median: metric.statistics.median,
+                    average: metric.statistics.average,
+                    p80: metric.statistics.p80,
+                    p90: metric.statistics.p90,
+                    p99: metric.statistics.p99,
+                    eventCount: metric.eventCount,
+                };
+                metricsMap.get(key).set(metric.metricName, values);
+                const eventCountKey = `${metric.metricName}:${appPlatform}`;
+                totalEventCounts.set(eventCountKey, (totalEventCounts.get(eventCountKey) ?? 0) + metric.eventCount);
+            }
+        }
+    }
+    return { metricsMap, buildNumbersMap, updateIdsMap, totalEventCounts };
+}

package/build/observe/fetchVersions.d.ts

@@ -0,0 +1,7 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppObserveAppVersion, AppPlatform } from '../graphql/generated';
+export interface AppVersionsResult {
+    platform: AppPlatform;
+    appVersions: AppObserveAppVersion[];
+}
+export declare function fetchObserveVersionsAsync(graphqlClient: ExpoGraphqlClient, appId: string, platforms: AppPlatform[], startTime: string, endTime: string): Promise<AppVersionsResult[]>;

package/build/observe/fetchVersions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchObserveVersionsAsync = fetchObserveVersionsAsync;
+const tslib_1 = require("tslib");
+const generated_1 = require("../graphql/generated");
+const ObserveQuery_1 = require("../graphql/queries/ObserveQuery");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const appPlatformToObservePlatform = {
+    [generated_1.AppPlatform.Android]: generated_1.AppObservePlatform.Android,
+    [generated_1.AppPlatform.Ios]: generated_1.AppObservePlatform.Ios,
+};
+async function fetchObserveVersionsAsync(graphqlClient, appId, platforms, startTime, endTime) {
+    const queries = platforms.map(async (appPlatform) => {
+        const observePlatform = appPlatformToObservePlatform[appPlatform];
+        try {
+            const appVersions = await ObserveQuery_1.ObserveQuery.appVersionsAsync(graphqlClient, {
+                appId,
+                platform: observePlatform,
+                startTime,
+                endTime,
+            });
+            return { platform: appPlatform, appVersions };
+        }
+        catch (error) {
+            log_1.default.warn(`Failed to fetch app versions for ${observePlatform}: ${error.message}`);
+            return null;
+        }
+    });
+    const results = await Promise.all(queries);
+    return results.filter((r) => r !== null);
+}

package/build/observe/formatEvents.d.ts

@@ -0,0 +1,31 @@
+import { AppObserveEvent, PageInfo } from '../graphql/generated';
+export interface ObserveEventJson {
+    id: string;
+    metricName: string;
+    metricValue: number;
+    appVersion: string;
+    appBuildNumber: string;
+    appUpdateId: string | null;
+    deviceModel: string;
+    deviceOs: string;
+    deviceOsVersion: string;
+    countryCode: string | null;
+    sessionId: string | null;
+    easClientId: string;
+    timestamp: string;
+}
+export interface BuildEventsTableOptions {
+    metricName: string;
+    daysBack?: number;
+    startTime?: string;
+    endTime?: string;
+    totalEventCount?: number;
+}
+export declare function buildObserveEventsTable(events: AppObserveEvent[], pageInfo: PageInfo, options?: BuildEventsTableOptions): string;
+export declare function buildObserveEventsJson(events: AppObserveEvent[], pageInfo: PageInfo): {
+    events: ObserveEventJson[];
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | null;
+    };
+};

package/build/observe/formatEvents.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObserveEventsTable = buildObserveEventsTable;
+exports.buildObserveEventsJson = buildObserveEventsJson;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const metricNames_1 = require("./metricNames");
+function formatTimestamp(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+function formatDate(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    });
+}
+function buildObserveEventsTable(events, pageInfo, options) {
+    if (events.length === 0) {
+        return chalk_1.default.yellow('No events found.');
+    }
+    const hasUpdates = events.some(e => e.appUpdateId);
+    const headers = [
+        'Value',
+        'App Version',
+        ...(hasUpdates ? ['Update'] : []),
+        'Platform',
+        'Device',
+        'Country',
+        'Timestamp',
+    ];
+    const rows = events.map(event => [
+        `${event.metricValue.toFixed(2)}s`,
+        `${event.appVersion} (${event.appBuildNumber})`,
+        ...(hasUpdates ? [event.appUpdateId ?? '-'] : []),
+        `${event.deviceOs} ${event.deviceOsVersion}`,
+        event.deviceModel,
+        event.countryCode ?? '-',
+        formatTimestamp(event.timestamp),
+    ]);
+    const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+    const separatorLine = colWidths.map(w => '-'.repeat(w)).join('  ');
+    const dataLines = rows.map(row => row.map((cell, i) => cell.padEnd(colWidths[i])).join('  '));
+    const lines = [];
+    if (options) {
+        const metricDisplay = (0, metricNames_1.getMetricDisplayName)(options.metricName);
+        let timeDesc;
+        if (options.daysBack) {
+            timeDesc = `for the last ${options.daysBack} days`;
+        }
+        else if (options.startTime && options.endTime) {
+            timeDesc = `from ${formatDate(options.startTime)} to ${formatDate(options.endTime)}`;
+        }
+        else {
+            timeDesc = '';
+        }
+        const totalDesc = options.totalEventCount != null
+            ? ` — ${options.totalEventCount.toLocaleString()} total events`
+            : '';
+        lines.push(chalk_1.default.bold(`${metricDisplay} events ${timeDesc}${totalDesc}`.trim()), '');
+    }
+    lines.push(chalk_1.default.bold(headerLine), separatorLine, ...dataLines);
+    if (pageInfo.hasNextPage && pageInfo.endCursor) {
+        lines.push('', `Next page: --after ${pageInfo.endCursor}`);
+    }
+    return lines.join('\n');
+}
+function buildObserveEventsJson(events, pageInfo) {
+    return {
+        events: events.map(event => ({
+            id: event.id,
+            metricName: event.metricName,
+            metricValue: event.metricValue,
+            appVersion: event.appVersion,
+            appBuildNumber: event.appBuildNumber,
+            appUpdateId: event.appUpdateId ?? null,
+            deviceModel: event.deviceModel,
+            deviceOs: event.deviceOs,
+            deviceOsVersion: event.deviceOsVersion,
+            countryCode: event.countryCode ?? null,
+            sessionId: event.sessionId ?? null,
+            easClientId: event.easClientId,
+            timestamp: event.timestamp,
+        })),
+        pageInfo: {
+            hasNextPage: pageInfo.hasNextPage,
+            endCursor: pageInfo.endCursor ?? null,
+        },
+    };
+}

package/build/observe/formatMetrics.d.ts

@@ -0,0 +1,38 @@
+import { AppPlatform } from '../graphql/generated';
+export type StatisticKey = 'min' | 'max' | 'median' | 'average' | 'p80' | 'p90' | 'p99' | 'eventCount';
+export declare const STAT_ALIASES: Record<string, StatisticKey>;
+export declare const STAT_DISPLAY_NAMES: Record<StatisticKey, string>;
+export declare function resolveStatKey(input: string): StatisticKey;
+export interface MetricValues {
+    min: number | null | undefined;
+    max: number | null | undefined;
+    median: number | null | undefined;
+    average: number | null | undefined;
+    p80: number | null | undefined;
+    p90: number | null | undefined;
+    p99: number | null | undefined;
+    eventCount: number | null | undefined;
+}
+type ObserveMetricsKey = `${string}:${AppPlatform}`;
+export type ObserveMetricsMap = Map<ObserveMetricsKey, Map<string, MetricValues>>;
+export type BuildNumbersMap = Map<ObserveMetricsKey, string[]>;
+export type UpdateIdsMap = Map<ObserveMetricsKey, string[]>;
+export declare function makeMetricsKey(appVersion: string, platform: AppPlatform): ObserveMetricsKey;
+export type MetricValuesJson = Partial<Record<StatisticKey, number | null>>;
+export interface ObserveMetricsVersionResult {
+    appVersion: string;
+    platform: AppPlatform;
+    metrics: Record<string, MetricValuesJson>;
+}
+export interface ObserveMetricsJsonOutput {
+    versions: ObserveMetricsVersionResult[];
+    totalEventCounts: Record<string, Record<string, number>>;
+}
+export declare function buildObserveMetricsJson(metricsMap: ObserveMetricsMap, metricNames: string[], stats: StatisticKey[], totalEventCounts?: Map<string, number>): ObserveMetricsJsonOutput;
+export declare function buildObserveMetricsTable(metricsMap: ObserveMetricsMap, metricNames: string[], stats: StatisticKey[], options?: {
+    daysBack?: number;
+    buildNumbersMap?: BuildNumbersMap;
+    updateIdsMap?: UpdateIdsMap;
+    totalEventCounts?: Map<string, number>;
+}): string;
+export {};

package/build/observe/formatMetrics.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STAT_DISPLAY_NAMES = exports.STAT_ALIASES = void 0;
+exports.resolveStatKey = resolveStatKey;
+exports.makeMetricsKey = makeMetricsKey;
+exports.buildObserveMetricsJson = buildObserveMetricsJson;
+exports.buildObserveMetricsTable = buildObserveMetricsTable;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const errors_1 = require("../commandUtils/errors");
+const platform_1 = require("../platform");
+const metricNames_1 = require("./metricNames");
+exports.STAT_ALIASES = {
+    min: 'min',
+    max: 'max',
+    med: 'median',
+    median: 'median',
+    avg: 'average',
+    average: 'average',
+    p80: 'p80',
+    p90: 'p90',
+    p99: 'p99',
+    count: 'eventCount',
+    event_count: 'eventCount',
+    eventCount: 'eventCount',
+};
+exports.STAT_DISPLAY_NAMES = {
+    min: 'Min',
+    max: 'Max',
+    median: 'Med',
+    average: 'Avg',
+    p80: 'P80',
+    p90: 'P90',
+    p99: 'P99',
+    eventCount: 'Count',
+};
+function resolveStatKey(input) {
+    const resolved = exports.STAT_ALIASES[input];
+    if (resolved) {
+        return resolved;
+    }
+    throw new errors_1.EasCommandError(`Unknown statistic: "${input}". Valid options: ${Object.keys(exports.STAT_ALIASES).join(', ')}`);
+}
+function formatStatValue(stat, value) {
+    if (value == null) {
+        return '-';
+    }
+    if (stat === 'eventCount') {
+        return String(value);
+    }
+    return `${value.toFixed(2)}s`;
+}
+function formatMergedCell(stat, statValue, eventCount) {
+    const formatted = formatStatValue(stat, statValue);
+    const count = eventCount != null ? String(eventCount) : '-';
+    return `${formatted} (${count})`;
+}
+function makeMetricsKey(appVersion, platform) {
+    return `${appVersion}:${platform}`;
+}
+function parseMetricsKey(key) {
+    const lastColon = key.lastIndexOf(':');
+    return {
+        appVersion: key.slice(0, lastColon),
+        platform: key.slice(lastColon + 1),
+    };
+}
+function buildObserveMetricsJson(metricsMap, metricNames, stats, totalEventCounts) {
+    const versions = [];
+    for (const [key, versionMetrics] of metricsMap) {
+        const { appVersion, platform } = parseMetricsKey(key);
+        const metrics = {};
+        for (const metricName of metricNames) {
+            const values = versionMetrics.get(metricName);
+            const statValues = {};
+            for (const stat of stats) {
+                statValues[stat] = values?.[stat] ?? null;
+            }
+            metrics[metricName] = statValues;
+        }
+        versions.push({ appVersion, platform, metrics });
+    }
+    // Group total event counts by metric → platform
+    const counts = {};
+    if (totalEventCounts) {
+        for (const [key, count] of totalEventCounts) {
+            const lastColon = key.lastIndexOf(':');
+            const metricName = key.slice(0, lastColon);
+            const platform = key.slice(lastColon + 1);
+            if (!counts[metricName]) {
+                counts[metricName] = {};
+            }
+            counts[metricName][platform] = count;
+        }
+    }
+    return { versions, totalEventCounts: counts };
+}
+function buildStatsDescription(displayStats) {
+    return displayStats.map(s => exports.STAT_DISPLAY_NAMES[s]).join(', ');
+}
+function buildTimeRangeDescription(daysBack) {
+    if (daysBack) {
+        return `for the last ${daysBack} days`;
+    }
+    return '';
+}
+function renderTable(headers, rows, footerRow) {
+    const allRows = footerRow ? [...rows, footerRow] : rows;
+    const colWidths = headers.map((h, i) => Math.max(h.length, ...allRows.map(r => (r[i] ?? '').length)));
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+    const separatorLine = colWidths.map(w => '-'.repeat(w)).join('  ');
+    const dataLines = rows.map(row => row.map((cell, i) => cell.padEnd(colWidths[i])).join('  '));
+    const lines = [chalk_1.default.bold(headerLine), separatorLine, ...dataLines];
+    if (footerRow) {
+        lines.push(separatorLine);
+        lines.push(footerRow.map((cell, i) => cell.padEnd(colWidths[i])).join('  '));
+    }
+    return lines.join('\n');
+}
+function buildObserveMetricsTable(metricsMap, metricNames, stats, options) {
+    const { versions: results } = buildObserveMetricsJson(metricsMap, metricNames, stats);
+    if (results.length === 0) {
+        return chalk_1.default.yellow('No metrics data found.');
+    }
+    const displayStats = stats.filter(s => s !== 'eventCount');
+    const hasEventCount = stats.includes('eventCount');
+    // Build summary header
+    const statsDesc = displayStats.length > 0 ? buildStatsDescription(displayStats) : 'Event count';
+    const timeDesc = buildTimeRangeDescription(options?.daysBack);
+    const countSuffix = hasEventCount && displayStats.length > 0 ? ' (event count)' : '';
+    const summaryLine = `${statsDesc} values${countSuffix}${timeDesc ? ` ${timeDesc}` : ''}`;
+    // Group results by platform
+    const byPlatform = new Map();
+    for (const result of results) {
+        if (!byPlatform.has(result.platform)) {
+            byPlatform.set(result.platform, []);
+        }
+        byPlatform.get(result.platform).push(result);
+    }
+    // Build metric column headers
+    const metricHeaders = [];
+    for (const m of metricNames) {
+        const name = (0, metricNames_1.getMetricDisplayName)(m);
+        if (displayStats.length > 0 && hasEventCount) {
+            // Merged mode: one column per metric
+            metricHeaders.push(name);
+        }
+        else {
+            // Separate columns per stat
+            for (const stat of displayStats.length > 0
+                ? displayStats
+                : ['eventCount']) {
+                metricHeaders.push(`${name} ${exports.STAT_DISPLAY_NAMES[stat]}`);
+            }
+        }
+    }
+    // Check if any version has updates
+    const hasUpdates = options?.updateIdsMap
+        ? Array.from(options.updateIdsMap.values()).some(ids => ids.length > 0)
+        : false;
+    const headers = ['App Version', ...(hasUpdates ? ['Updates'] : []), ...metricHeaders];
+    const sections = [chalk_1.default.bold(summaryLine)];
+    for (const [platform, platformResults] of byPlatform) {
+        sections.push('');
+        sections.push(chalk_1.default.bold(platform_1.appPlatformDisplayNames[platform]));
+        const rows = platformResults.map(result => {
+            const key = makeMetricsKey(result.appVersion, result.platform);
+            const buildNumbers = options?.buildNumbersMap?.get(key);
+            const versionLabel = buildNumbers?.length
+                ? `${result.appVersion} (${buildNumbers.join(', ')})`
+                : result.appVersion;
+            const updateIds = options?.updateIdsMap?.get(key);
+            const updatesLabel = updateIds?.length ? updateIds.join(', ') : '';
+            const metricCells = [];
+            for (const m of metricNames) {
+                const values = result.metrics[m];
+                if (displayStats.length > 0 && hasEventCount) {
+                    for (const stat of displayStats) {
+                        metricCells.push(formatMergedCell(stat, values?.[stat] ?? null, values?.eventCount ?? null));
+                    }
+                }
+                else {
+                    for (const stat of displayStats.length > 0
+                        ? displayStats
+                        : ['eventCount']) {
+                        metricCells.push(formatStatValue(stat, values?.[stat] ?? null));
+                    }
+                }
+            }
+            return [versionLabel, ...(hasUpdates ? [updatesLabel] : []), ...metricCells];
+        });
+        let footerRow;
+        if (options?.totalEventCounts) {
+            const countCells = [];
+            for (const m of metricNames) {
+                const count = options.totalEventCounts.get(`${m}:${platform}`);
+                countCells.push(count != null ? count.toLocaleString() : '-');
+            }
+            if (countCells.some(c => c !== '-')) {
+                footerRow = ['Total events', ...(hasUpdates ? [''] : []), ...countCells];
+            }
+        }
+        sections.push(renderTable(headers, rows, footerRow));
+    }
+    return sections.join('\n');
+}

package/build/observe/formatVersions.d.ts

@@ -0,0 +1,32 @@
+import { AppVersionsResult } from './fetchVersions';
+export interface AppVersionJson {
+    platform: string;
+    appVersion: string;
+    firstSeenAt: string;
+    eventCount: number;
+    uniqueUserCount: number;
+    buildNumbers: AppBuildNumberJson[];
+    updates: AppUpdateJson[];
+}
+export interface AppBuildNumberJson {
+    appBuildNumber: string;
+    firstSeenAt: string;
+    eventCount: number;
+    uniqueUserCount: number;
+    easBuilds: AppEasBuildJson[];
+}
+export interface AppUpdateJson {
+    appUpdateId: string;
+    firstSeenAt: string;
+    eventCount: number;
+    uniqueUserCount: number;
+    easBuilds: AppEasBuildJson[];
+}
+export interface AppEasBuildJson {
+    easBuildId: string;
+    firstSeenAt: string;
+    eventCount: number;
+    uniqueUserCount: number;
+}
+export declare function buildObserveVersionsJson(results: AppVersionsResult[]): AppVersionJson[];
+export declare function buildObserveVersionsTable(results: AppVersionsResult[]): string;

package/build/observe/formatVersions.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObserveVersionsJson = buildObserveVersionsJson;
+exports.buildObserveVersionsTable = buildObserveVersionsTable;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const platform_1 = require("../platform");
+function formatDate(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    });
+}
+function mapEasBuilds(easBuilds) {
+    return easBuilds.map(b => ({
+        easBuildId: b.easBuildId,
+        firstSeenAt: b.firstSeenAt,
+        eventCount: b.eventCount,
+        uniqueUserCount: b.uniqueUserCount,
+    }));
+}
+function mapBuildNumbers(buildNumbers) {
+    return buildNumbers.map(bn => ({
+        appBuildNumber: bn.appBuildNumber,
+        firstSeenAt: bn.firstSeenAt,
+        eventCount: bn.eventCount,
+        uniqueUserCount: bn.uniqueUserCount,
+        easBuilds: mapEasBuilds(bn.easBuilds),
+    }));
+}
+function mapUpdates(updates) {
+    return updates.map(u => ({
+        appUpdateId: u.appUpdateId,
+        firstSeenAt: u.firstSeenAt,
+        eventCount: u.eventCount,
+        uniqueUserCount: u.uniqueUserCount,
+        easBuilds: mapEasBuilds(u.easBuilds),
+    }));
+}
+function buildObserveVersionsJson(results) {
+    const output = [];
+    for (const { platform, appVersions } of results) {
+        for (const v of appVersions) {
+            output.push({
+                platform: platform,
+                appVersion: v.appVersion,
+                firstSeenAt: v.firstSeenAt,
+                eventCount: v.eventCount,
+                uniqueUserCount: v.uniqueUserCount,
+                buildNumbers: mapBuildNumbers(v.buildNumbers),
+                updates: mapUpdates(v.updates),
+            });
+        }
+    }
+    return output;
+}
+function renderTable(headers, rows) {
+    const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+    const separatorLine = colWidths.map(w => '-'.repeat(w)).join('  ');
+    const dataLines = rows.map(row => row.map((cell, i) => cell.padEnd(colWidths[i])).join('  '));
+    return [chalk_1.default.bold(headerLine), separatorLine, ...dataLines].join('\n');
+}
+function buildObserveVersionsTable(results) {
+    const hasAnyVersions = results.some(r => r.appVersions.length > 0);
+    if (!hasAnyVersions) {
+        return chalk_1.default.yellow('No app versions found.');
+    }
+    const headers = ['App Version', 'First Seen', 'Events', 'Users', 'Builds', 'Updates'];
+    const sections = [];
+    for (const { platform, appVersions } of results) {
+        if (appVersions.length === 0) {
+            continue;
+        }
+        if (sections.length > 0) {
+            sections.push('');
+        }
+        sections.push(chalk_1.default.bold(platform_1.appPlatformDisplayNames[platform]));
+        const rows = appVersions.map(version => [
+            version.appVersion,
+            formatDate(version.firstSeenAt),
+            String(version.eventCount),
+            String(version.uniqueUserCount),
+            String(version.buildNumbers.length),
+            String(version.updates.length),
+        ]);
+        sections.push(renderTable(headers, rows));
+    }
+    return sections.join('\n');
+}

package/build/observe/metricNames.d.ts

@@ -0,0 +1,4 @@
+export declare const METRIC_ALIASES: Record<string, string>;
+export declare const METRIC_SHORT_NAMES: Record<string, string>;
+export declare function resolveMetricName(input: string): string;
+export declare function getMetricDisplayName(metricName: string): string;

package/build/observe/metricNames.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METRIC_SHORT_NAMES = exports.METRIC_ALIASES = void 0;
+exports.resolveMetricName = resolveMetricName;
+exports.getMetricDisplayName = getMetricDisplayName;
+const errors_1 = require("../commandUtils/errors");
+exports.METRIC_ALIASES = {
+    tti: 'expo.app_startup.tti',
+    ttr: 'expo.app_startup.ttr',
+    cold_launch: 'expo.app_startup.cold_launch_time',
+    warm_launch: 'expo.app_startup.warm_launch_time',
+    bundle_load: 'expo.app_startup.bundle_load_time',
+};
+const KNOWN_FULL_NAMES = new Set(Object.values(exports.METRIC_ALIASES));
+exports.METRIC_SHORT_NAMES = {
+    'expo.app_startup.cold_launch_time': 'Cold Launch',
+    'expo.app_startup.warm_launch_time': 'Warm Launch',
+    'expo.app_startup.tti': 'TTI',
+    'expo.app_startup.ttr': 'TTR',
+    'expo.app_startup.bundle_load_time': 'Bundle Load',
+};
+function resolveMetricName(input) {
+    if (exports.METRIC_ALIASES[input]) {
+        return exports.METRIC_ALIASES[input];
+    }
+    if (KNOWN_FULL_NAMES.has(input) || input.includes('.')) {
+        return input;
+    }
+    throw new errors_1.EasCommandError(`Unknown metric: "${input}". Use a full metric name (e.g. expo.app_startup.tti) or a short alias: ${Object.keys(exports.METRIC_ALIASES).join(', ')}`);
+}
+function getMetricDisplayName(metricName) {
+    return exports.METRIC_SHORT_NAMES[metricName] ?? metricName;
+}

package/build/observe/startAndEndTime.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_DAYS_BACK = 60;
+export declare function startAndEndTime({ daysBack, start, end, }: {
+    daysBack?: number;
+    start?: string;
+    end?: string;
+}): {
+    startTime: string;
+    endTime: string;
+};
+export declare function resolveTimeRange(flags: {
+    days?: number;
+    start?: string;
+    end?: string;
+}): {
+    daysBack?: number;
+    startTime: string;
+    endTime: string;
+};