eas-cli 18.4.0 → 18.6.0

package/build/metadata/auth.js

@@ -4,8 +4,14 @@ exports.getAppStoreAuthAsync = getAppStoreAuthAsync;
 const tslib_1 = require("tslib");
 const apple_utils_1 = require("@expo/apple-utils");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const authenticate_1 = require("../credentials/ios/appstore/authenticate");
+const authenticateTypes_1 = require("../credentials/ios/appstore/authenticateTypes");
+const resolveCredentials_1 = require("../credentials/ios/appstore/resolveCredentials");
+const AppStoreConnectApiKeyQuery_1 = require("../graphql/queries/AppStoreConnectApiKeyQuery");
+const log_1 = tslib_1.__importDefault(require("../log"));
 const bundleIdentifier_1 = require("../project/ios/bundleIdentifier");
+const projectUtils_1 = require("../project/projectUtils");
 /**
  * Resolve the bundle identifier from the selected submit profile.
  * This bundle identifier is used as target for the metadata submission.
@@ -16,15 +22,103 @@ async function resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, vc
     }
     return await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient);
 }
+/**
+ * Try to resolve an ASC API key from the submit profile or EAS credentials service.
+ * Returns null if no key is available from these sources.
+ */
+async function tryResolveAscApiKeyAsync({ profile, graphqlClient, projectId, exp, bundleId, }) {
+    // 1. Check submit profile for ASC API key fields
+    if ('ascApiKeyPath' in profile && 'ascApiKeyIssuerId' in profile && 'ascApiKeyId' in profile) {
+        const { ascApiKeyPath, ascApiKeyIssuerId, ascApiKeyId } = profile;
+        if (ascApiKeyPath && ascApiKeyIssuerId && ascApiKeyId) {
+            const keyP8 = await fs_1.default.promises.readFile(ascApiKeyPath, 'utf-8');
+            // Also try to get teamId from the profile if available
+            const teamId = 'appleTeamId' in profile ? profile.appleTeamId : undefined;
+            return {
+                ascApiKey: { keyP8, keyId: ascApiKeyId, issuerId: ascApiKeyIssuerId },
+                teamId,
+            };
+        }
+    }
+    // 2. Look up stored credentials via EAS credentials service
+    try {
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+        const appLookupParams = {
+            account,
+            projectName: exp.slug,
+            bundleIdentifier: bundleId,
+        };
+        // Import dynamically to avoid circular dependency issues
+        const { getAscApiKeyForAppSubmissionsAsync } = await Promise.resolve().then(() => tslib_1.__importStar(require('../credentials/ios/api/GraphqlClient')));
+        const ascKeyFragment = await getAscApiKeyForAppSubmissionsAsync(graphqlClient, appLookupParams);
+        if (ascKeyFragment) {
+            log_1.default.log('Using App Store Connect API Key from EAS credentials service.');
+            const fullKey = await AppStoreConnectApiKeyQuery_1.AppStoreConnectApiKeyQuery.getByIdAsync(graphqlClient, ascKeyFragment.id);
+            return {
+                ascApiKey: {
+                    keyP8: fullKey.keyP8,
+                    keyId: fullKey.keyIdentifier,
+                    issuerId: fullKey.issuerIdentifier,
+                },
+                teamId: ascKeyFragment.appleTeam?.appleTeamIdentifier,
+                teamName: ascKeyFragment.appleTeam?.appleTeamName ?? undefined,
+            };
+        }
+    }
+    catch (error) {
+        // If we can't look up credentials, that's fine — we'll fall back
+        log_1.default.warn(`Could not look up stored ASC API key: ${error.message}`);
+    }
+    return null;
+}
 /**
  * To start syncing ASC entities, we need access to the apple utils App instance.
  * This resolves both the authentication and that App instance.
+ *
+ * Resolution order for authentication:
+ * 1. ASC API key from environment variables (EXPO_ASC_API_KEY_PATH, etc.)
+ * 2. ASC API key from submit profile (ascApiKeyPath, etc. in eas.json)
+ * 3. ASC API key from EAS credentials service
+ * 4. Interactive cookie auth (only when not in non-interactive mode)
  */
-async function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }) {
+async function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, nonInteractive, graphqlClient, projectId, }) {
     const bundleId = await resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, credentialsCtx.vcsClient);
+    // Try to resolve an ASC API key from profile or credentials service
+    const resolvedKey = await tryResolveAscApiKeyAsync({
+        profile,
+        graphqlClient,
+        projectId,
+        exp,
+        bundleId,
+    });
+    if (resolvedKey || (0, resolveCredentials_1.hasAscEnvVars)()) {
+        const authOptions = {
+            mode: authenticateTypes_1.AuthenticationMode.API_KEY,
+            ...(resolvedKey
+                ? {
+                    ascApiKey: resolvedKey.ascApiKey,
+                    teamId: resolvedKey.teamId,
+                    teamName: resolvedKey.teamName,
+                    // Default to COMPANY_OR_ORGANIZATION to avoid prompting for team type
+                    teamType: authenticateTypes_1.AppleTeamType.COMPANY_OR_ORGANIZATION,
+                }
+                : {}),
+        };
+        const authCtx = await credentialsCtx.appStore.ensureAuthenticatedAsync(authOptions);
+        (0, assert_1.default)(authCtx.authState, 'Failed to authenticate with App Store Connect');
+        const app = await apple_utils_1.App.findAsync((0, authenticate_1.getRequestContext)(authCtx), { bundleId });
+        (0, assert_1.default)(app, `Failed to load app "${bundleId}" from App Store Connect`);
+        return { app, auth: authCtx.authState };
+    }
+    if (nonInteractive) {
+        throw new Error('No App Store Connect API Key found. In non-interactive mode, provide one via:\n' +
+            '  - Environment variables: EXPO_ASC_API_KEY_PATH, EXPO_ASC_KEY_ID, EXPO_ASC_ISSUER_ID\n' +
+            '  - eas.json submit profile: ascApiKeyPath, ascApiKeyId, ascApiKeyIssuerId\n' +
+            '  - EAS credentials service: run `eas credentials` to set up an API key');
+    }
+    // Fall back to interactive cookie auth
     const authCtx = await credentialsCtx.appStore.ensureAuthenticatedAsync();
     (0, assert_1.default)(authCtx.authState, 'Failed to authenticate with App Store Connect');
-    // TODO: improve error handling by mentioning possible configuration errors
     const app = await apple_utils_1.App.findAsync((0, authenticate_1.getRequestContext)(authCtx), { bundleId });
     (0, assert_1.default)(app, `Failed to load app "${bundleId}" from App Store Connect`);
     return { app, auth: authCtx.authState };

package/build/metadata/download.d.ts

@@ -1,15 +1,19 @@
 import { ExpoConfig } from '@expo/config';
 import { SubmitProfile } from '@expo/eas-json';
 import { Analytics } from '../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { CredentialsContext } from '../credentials/context';
 /**
  * Generate a local store configuration from the stores.
  * Note, only App Store is supported at this time.
  */
-export declare function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+export declare function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, nonInteractive, graphqlClient, projectId, }: {
     projectDir: string;
     profile: SubmitProfile;
     exp: ExpoConfig;
     analytics: Analytics;
     credentialsCtx: CredentialsContext;
+    nonInteractive: boolean;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
 }): Promise<string>;

package/build/metadata/download.js

@@ -16,16 +16,21 @@ const prompts_1 = require("../prompts");
  * Generate a local store configuration from the stores.
  * Note, only App Store is supported at this time.
  */
-async function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
+async function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, nonInteractive, graphqlClient, projectId, }) {
     const filePath = (0, resolve_1.getStaticConfigFilePath)({ projectDir, profile });
     const fileExists = await fs_extra_1.default.pathExists(filePath);
     if (fileExists) {
-        const filePathRelative = path_1.default.relative(projectDir, filePath);
-        const overwrite = await (0, prompts_1.confirmAsync)({
-            message: `Do you want to overwrite the existing "${filePathRelative}"?`,
-        });
-        if (!overwrite) {
-            throw new errors_1.MetadataValidationError(`Store config already exists at "${filePath}"`);
+        if (nonInteractive) {
+            log_1.default.log(`Overwriting existing store config at "${path_1.default.relative(projectDir, filePath)}".`);
+        }
+        else {
+            const filePathRelative = path_1.default.relative(projectDir, filePath);
+            const overwrite = await (0, prompts_1.confirmAsync)({
+                message: `Do you want to overwrite the existing "${filePathRelative}"?`,
+            });
+            if (!overwrite) {
+                throw new errors_1.MetadataValidationError(`Store config already exists at "${filePath}"`);
+            }
         }
     }
     const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
@@ -33,6 +38,9 @@ async function downloadMetadataAsync({ projectDir, profile, exp, analytics, cred
         credentialsCtx,
         projectDir,
         profile,
+        nonInteractive,
+        graphqlClient,
+        projectId,
     });
     const { unsubscribeTelemetry, executionId } = await (0, telemetry_1.subscribeTelemetryAsync)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
     log_1.default.addNewLineIfNone();
@@ -40,7 +48,7 @@ async function downloadMetadataAsync({ projectDir, profile, exp, analytics, cred
     const errors = [];
     const config = (0, resolve_1.createAppleWriter)();
     const tasks = (0, tasks_1.createAppleTasks)();
-    const taskCtx = { app };
+    const taskCtx = { app, projectDir };
     for (const task of tasks) {
         try {
             await task.prepareAsync({ context: taskCtx });

package/build/metadata/upload.d.ts

@@ -1,17 +1,21 @@
 import { ExpoConfig } from '@expo/config';
 import { SubmitProfile } from '@expo/eas-json';
 import { Analytics } from '../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { CredentialsContext } from '../credentials/context';
 /**
  * Sync a local store configuration with the stores.
  * Note, only App Store is supported at this time.
  */
-export declare function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+export declare function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, nonInteractive, graphqlClient, projectId, }: {
     projectDir: string;
     profile: SubmitProfile;
     exp: ExpoConfig;
     analytics: Analytics;
     credentialsCtx: CredentialsContext;
+    nonInteractive: boolean;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
 }): Promise<{
     appleLink: string;
 }>;

package/build/metadata/upload.js

@@ -14,13 +14,16 @@ const prompts_1 = require("../prompts");
  * Sync a local store configuration with the stores.
  * Note, only App Store is supported at this time.
  */
-async function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }) {
-    const storeConfig = await loadConfigWithValidationPromptAsync(projectDir, profile);
+async function uploadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, nonInteractive, graphqlClient, projectId, }) {
+    const storeConfig = await loadConfigWithValidationPromptAsync(projectDir, profile, nonInteractive);
     const { app, auth } = await (0, auth_1.getAppStoreAuthAsync)({
         exp,
         credentialsCtx,
         projectDir,
         profile,
+        nonInteractive,
+        graphqlClient,
+        projectId,
     });
     const { unsubscribeTelemetry, executionId } = await (0, telemetry_1.subscribeTelemetryAsync)(analytics, AnalyticsManager_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
     log_1.default.addNewLineIfNone();
@@ -32,7 +35,7 @@ async function uploadMetadataAsync({ projectDir, profile, exp, analytics, creden
         // This version is the parent model of all changes we are going to push.
         version: config.getVersion()?.versionString,
     });
-    const taskCtx = { app };
+    const taskCtx = { app, projectDir };
     for (const task of tasks) {
         try {
             await task.prepareAsync({ context: taskCtx });
@@ -55,12 +58,16 @@ async function uploadMetadataAsync({ projectDir, profile, exp, analytics, creden
     }
     return { appleLink: `https://appstoreconnect.apple.com/apps/${app.id}/appstore` };
 }
-async function loadConfigWithValidationPromptAsync(projectDir, profile) {
+async function loadConfigWithValidationPromptAsync(projectDir, profile, nonInteractive) {
     try {
         return await (0, resolve_1.loadConfigAsync)({ projectDir, profile });
     }
     catch (error) {
         if (error instanceof errors_1.MetadataValidationError) {
+            if (nonInteractive) {
+                (0, errors_1.logMetadataValidationError)(error);
+                throw error;
+            }
             (0, errors_1.logMetadataValidationError)(error);
             log_1.default.newLine();
             log_1.default.warn('Without further updates, the current store configuration can fail to be synchronized with the App Store or pass App Store review.');

package/build/observe/fetchEvents.d.ts

@@ -0,0 +1,27 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppObserveEvent, AppObserveEventsOrderBy, AppObservePlatform, AppPlatform, PageInfo } from '../graphql/generated';
+export declare enum EventsOrderPreset {
+    Slowest = "SLOWEST",
+    Fastest = "FASTEST",
+    Newest = "NEWEST",
+    Oldest = "OLDEST"
+}
+export declare function resolveOrderBy(input: string): AppObserveEventsOrderBy;
+interface FetchObserveEventsOptions {
+    metricName: string;
+    orderBy: AppObserveEventsOrderBy;
+    limit: number;
+    after?: string;
+    startTime: string;
+    endTime: string;
+    platform?: AppObservePlatform;
+    appVersion?: string;
+    updateId?: string;
+}
+interface FetchObserveEventsResult {
+    events: AppObserveEvent[];
+    pageInfo: PageInfo;
+}
+export declare function fetchObserveEventsAsync(graphqlClient: ExpoGraphqlClient, appId: string, options: FetchObserveEventsOptions): Promise<FetchObserveEventsResult>;
+export declare function fetchTotalEventCountAsync(graphqlClient: ExpoGraphqlClient, appId: string, metricName: string, platforms: AppPlatform[], startTime: string, endTime: string): Promise<number>;
+export {};

package/build/observe/fetchEvents.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsOrderPreset = void 0;
+exports.resolveOrderBy = resolveOrderBy;
+exports.fetchObserveEventsAsync = fetchObserveEventsAsync;
+exports.fetchTotalEventCountAsync = fetchTotalEventCountAsync;
+const generated_1 = require("../graphql/generated");
+const ObserveQuery_1 = require("../graphql/queries/ObserveQuery");
+var EventsOrderPreset;
+(function (EventsOrderPreset) {
+    EventsOrderPreset["Slowest"] = "SLOWEST";
+    EventsOrderPreset["Fastest"] = "FASTEST";
+    EventsOrderPreset["Newest"] = "NEWEST";
+    EventsOrderPreset["Oldest"] = "OLDEST";
+})(EventsOrderPreset || (exports.EventsOrderPreset = EventsOrderPreset = {}));
+function resolveOrderBy(input) {
+    const preset = input.toUpperCase();
+    switch (preset) {
+        case EventsOrderPreset.Slowest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.MetricValue,
+                direction: generated_1.AppObserveEventsOrderByDirection.Desc,
+            };
+        case EventsOrderPreset.Fastest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.MetricValue,
+                direction: generated_1.AppObserveEventsOrderByDirection.Asc,
+            };
+        case EventsOrderPreset.Newest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.Timestamp,
+                direction: generated_1.AppObserveEventsOrderByDirection.Desc,
+            };
+        case EventsOrderPreset.Oldest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.Timestamp,
+                direction: generated_1.AppObserveEventsOrderByDirection.Asc,
+            };
+    }
+}
+async function fetchObserveEventsAsync(graphqlClient, appId, options) {
+    const filter = {
+        metricName: options.metricName,
+        startTime: options.startTime,
+        endTime: options.endTime,
+        ...(options.platform && { platform: options.platform }),
+        ...(options.appVersion && { appVersion: options.appVersion }),
+        ...(options.updateId && { appUpdateId: options.updateId }),
+    };
+    return await ObserveQuery_1.ObserveQuery.eventsAsync(graphqlClient, {
+        appId,
+        filter,
+        first: options.limit,
+        ...(options.after && { after: options.after }),
+        orderBy: options.orderBy,
+    });
+}
+const appPlatformToObservePlatform = {
+    [generated_1.AppPlatform.Android]: generated_1.AppObservePlatform.Android,
+    [generated_1.AppPlatform.Ios]: generated_1.AppObservePlatform.Ios,
+};
+async function fetchTotalEventCountAsync(graphqlClient, appId, metricName, platforms, startTime, endTime) {
+    const queries = platforms.map(async (appPlatform) => {
+        try {
+            const versions = await ObserveQuery_1.ObserveQuery.appVersionsAsync(graphqlClient, {
+                appId,
+                platform: appPlatformToObservePlatform[appPlatform],
+                startTime,
+                endTime,
+                metricNames: [metricName],
+            });
+            return versions.reduce((sum, v) => {
+                const metric = v.metrics.find(m => m.metricName === metricName);
+                return sum + (metric?.eventCount ?? 0);
+            }, 0);
+        }
+        catch {
+            return 0;
+        }
+    });
+    const counts = await Promise.all(queries);
+    return counts.reduce((a, b) => a + b, 0);
+}

package/build/observe/fetchMetrics.d.ts

@@ -0,0 +1,11 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppPlatform } from '../graphql/generated';
+import { BuildNumbersMap, ObserveMetricsMap, UpdateIdsMap } from './formatMetrics';
+export declare function validateDateFlag(value: string, flagName: string): void;
+export interface FetchObserveMetricsResult {
+    metricsMap: ObserveMetricsMap;
+    buildNumbersMap: BuildNumbersMap;
+    updateIdsMap: UpdateIdsMap;
+    totalEventCounts: Map<string, number>;
+}
+export declare function fetchObserveMetricsAsync(graphqlClient: ExpoGraphqlClient, appId: string, metricNames: string[], platforms: AppPlatform[], startTime: string, endTime: string): Promise<FetchObserveMetricsResult>;

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,
+        },
+    };
+}