eas-cli 18.7.0 → 18.8.0

package/build/channel/insights/formatInsights.d.ts

@@ -0,0 +1,47 @@
+import { ChannelRuntimeInsights } from '../../graphql/queries/ChannelInsightsQuery';
+export interface ChannelInsightsTimespan {
+    startTime: string;
+    endTime: string;
+    daysBack?: number;
+}
+export interface ChannelMostPopularUpdate {
+    rank: number;
+    groupId: string;
+    message: string | null;
+    platform: string;
+    totalUniqueUsers: number;
+}
+export interface ChannelInsightsSummary {
+    channelName: string;
+    runtimeVersion: string;
+    startTime: string;
+    endTime: string;
+    daysBack?: number;
+    embeddedUpdateTotalUniqueUsers: number;
+    otaTotalUniqueUsers: number;
+    mostPopularUpdates: ChannelMostPopularUpdate[];
+    cumulativeMetricsAtLastTimestamp: {
+        id: string;
+        label: string;
+        data: number;
+    }[];
+    uniqueUsersOverTime: {
+        labels: string[];
+        datasets: {
+            id: string;
+            label: string;
+            data: (number | null)[];
+        }[];
+    };
+    cumulativeMetricsOverTime: {
+        labels: string[];
+        datasets: {
+            id: string;
+            label: string;
+            data: (number | null)[];
+        }[];
+    };
+}
+export declare function toChannelInsightsSummary(channelName: string, runtimeVersion: string, insights: ChannelRuntimeInsights, timespan: ChannelInsightsTimespan): ChannelInsightsSummary;
+export declare function buildChannelInsightsJson(summary: ChannelInsightsSummary): object;
+export declare function buildChannelInsightsTable(summary: ChannelInsightsSummary): string;

package/build/channel/insights/formatInsights.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toChannelInsightsSummary = toChannelInsightsSummary;
+exports.buildChannelInsightsJson = buildChannelInsightsJson;
+exports.buildChannelInsightsTable = buildChannelInsightsTable;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const formatTimespan_1 = require("../../insights/formatTimespan");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const renderTextTable_1 = tslib_1.__importDefault(require("../../utils/renderTextTable"));
+function toChannelInsightsSummary(channelName, runtimeVersion, insights, timespan) {
+    const mostPopular = insights.mostPopularUpdates.map((u, i) => ({
+        rank: i + 1,
+        groupId: u.group,
+        message: u.message ?? null,
+        platform: u.platform,
+        totalUniqueUsers: u.insights.totalUniqueUsers,
+    }));
+    const otaTotalUniqueUsers = mostPopular.reduce((sum, u) => sum + u.totalUniqueUsers, 0);
+    return {
+        channelName,
+        runtimeVersion,
+        startTime: timespan.startTime,
+        endTime: timespan.endTime,
+        daysBack: timespan.daysBack,
+        embeddedUpdateTotalUniqueUsers: insights.embeddedUpdateTotalUniqueUsers,
+        otaTotalUniqueUsers,
+        mostPopularUpdates: mostPopular,
+        cumulativeMetricsAtLastTimestamp: insights.cumulativeMetricsOverTime.metricsAtLastTimestamp.map(m => ({ id: m.id, label: m.label, data: m.data })),
+        uniqueUsersOverTime: {
+            labels: insights.uniqueUsersOverTime.data.labels,
+            datasets: insights.uniqueUsersOverTime.data.datasets.map(d => ({
+                id: d.id,
+                label: d.label,
+                data: d.data,
+            })),
+        },
+        cumulativeMetricsOverTime: {
+            labels: insights.cumulativeMetricsOverTime.data.labels,
+            datasets: insights.cumulativeMetricsOverTime.data.datasets.map(d => ({
+                id: d.id,
+                label: d.label,
+                data: d.data,
+            })),
+        },
+    };
+}
+function buildChannelInsightsJson(summary) {
+    return {
+        channel: summary.channelName,
+        runtimeVersion: summary.runtimeVersion,
+        timespan: {
+            start: summary.startTime,
+            end: summary.endTime,
+            ...(summary.daysBack !== undefined ? { daysBack: summary.daysBack } : {}),
+        },
+        embeddedUpdateTotalUniqueUsers: summary.embeddedUpdateTotalUniqueUsers,
+        otaTotalUniqueUsers: summary.otaTotalUniqueUsers,
+        mostPopularUpdates: summary.mostPopularUpdates,
+        cumulativeMetricsAtLastTimestamp: summary.cumulativeMetricsAtLastTimestamp,
+        uniqueUsersOverTime: summary.uniqueUsersOverTime,
+        cumulativeMetricsOverTime: summary.cumulativeMetricsOverTime,
+    };
+}
+function buildChannelInsightsTable(summary) {
+    const sections = [];
+    sections.push(chalk_1.default.bold('Channel insights:'));
+    sections.push((0, formatFields_1.default)([
+        { label: 'Channel', value: summary.channelName },
+        { label: 'Runtime version', value: summary.runtimeVersion },
+        { label: 'Time range', value: (0, formatTimespan_1.formatTimespan)(summary) },
+        {
+            label: 'Embedded update users',
+            value: summary.embeddedUpdateTotalUniqueUsers.toLocaleString(),
+        },
+        { label: 'OTA update users', value: summary.otaTotalUniqueUsers.toLocaleString() },
+    ]));
+    if (summary.cumulativeMetricsAtLastTimestamp.length > 0) {
+        sections.push('');
+        sections.push(chalk_1.default.bold('Cumulative metrics at last timestamp:'));
+        sections.push((0, formatFields_1.default)(summary.cumulativeMetricsAtLastTimestamp.map(m => ({
+            label: m.label,
+            value: m.data.toLocaleString(),
+        }))));
+    }
+    if (summary.mostPopularUpdates.length > 0) {
+        sections.push('');
+        sections.push(chalk_1.default.bold(`Most popular updates${formatTrailingTimespan(summary)}:`));
+        sections.push(renderMostPopularTable(summary.mostPopularUpdates));
+    }
+    else {
+        sections.push('');
+        sections.push(chalk_1.default.yellow('No update launches recorded for this channel and runtime.'));
+    }
+    return sections.join('\n');
+}
+function formatTrailingTimespan(summary) {
+    return summary.daysBack ? ` (last ${summary.daysBack} days)` : '';
+}
+function renderMostPopularTable(rows) {
+    return (0, renderTextTable_1.default)(['#', 'Group ID', 'Platform', 'Unique users', 'Message'], rows.map(r => [
+        String(r.rank),
+        r.groupId,
+        r.platform,
+        r.totalUniqueUsers.toLocaleString(),
+        r.message ?? '',
+    ]));
+}

package/build/commands/channel/insights.d.ts

@@ -0,0 +1,18 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class ChannelInsights extends EasCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        channel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'runtime-version': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        days: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/channel/insights.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const formatInsights_1 = require("../../channel/insights/formatInsights");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const ChannelInsightsQuery_1 = require("../../graphql/queries/ChannelInsightsQuery");
+const timeRange_1 = require("../../insights/timeRange");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const json_1 = require("../../utils/json");
+class ChannelInsights extends EasCommand_1.default {
+    static description = 'display adoption, crash, and unique-user insights for a channel + runtime version';
+    static flags = {
+        channel: core_1.Flags.string({
+            description: 'Name of the channel.',
+            required: true,
+        }),
+        'runtime-version': core_1.Flags.string({
+            description: 'Runtime version to query insights for.',
+            required: true,
+        }),
+        days: core_1.Flags.integer({
+            description: 'Show insights from the last N days (default 7, mutually exclusive with --start/--end).',
+            min: 1,
+            exclusive: ['start', 'end'],
+        }),
+        start: core_1.Flags.string({
+            description: 'Start of insights time range (ISO date).',
+            exclusive: ['days'],
+        }),
+        end: core_1.Flags.string({
+            description: 'End of insights time range (ISO date).',
+            exclusive: ['days'],
+        }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(ChannelInsights);
+        const { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(ChannelInsights, { nonInteractive });
+        if (json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { daysBack, startTime, endTime } = (0, timeRange_1.resolveInsightsTimeRange)(flags);
+        const insights = await ChannelInsightsQuery_1.ChannelInsightsQuery.viewChannelRuntimeInsightsAsync(graphqlClient, {
+            appId: projectId,
+            channelName: flags.channel,
+            runtimeVersion: flags['runtime-version'],
+            startTime,
+            endTime,
+        });
+        const summary = (0, formatInsights_1.toChannelInsightsSummary)(flags.channel, flags['runtime-version'], insights, {
+            startTime,
+            endTime,
+            daysBack,
+        });
+        if (json) {
+            (0, json_1.printJsonOnlyOutput)((0, formatInsights_1.buildChannelInsightsJson)(summary));
+        }
+        else {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log((0, formatInsights_1.buildChannelInsightsTable)(summary));
+        }
+    }
+}
+exports.default = ChannelInsights;

package/build/commands/observe/events.d.ts

@@ -23,5 +23,6 @@ export default class ObserveEvents extends EasCommand {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
     };
+    private static loggedInOnlyContextDefinition;
     runAsync(): Promise<void>;
 }

package/build/commands/observe/events.js

@@ -71,12 +71,25 @@ class ObserveEvents extends EasCommand_1.default {
         ...this.ContextOptions.ProjectId,
         ...this.ContextOptions.LoggedIn,
     };
+    static loggedInOnlyContextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
     async runAsync() {
         const { flags, args } = await this.parse(ObserveEvents);
-        const { projectId: contextProjectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(ObserveEvents, {
-            nonInteractive: flags['non-interactive'],
-        });
-        const projectId = flags['project-id'] ?? contextProjectId;
+        let projectId;
+        let graphqlClient;
+        if (flags['project-id']) {
+            projectId = flags['project-id'];
+            const ctx = await this.getContextAsync({ contextDefinition: ObserveEvents.loggedInOnlyContextDefinition }, { nonInteractive: flags['non-interactive'] });
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
+        else {
+            const ctx = await this.getContextAsync(ObserveEvents, {
+                nonInteractive: flags['non-interactive'],
+            });
+            projectId = ctx.projectId;
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
         if (flags.json) {
             (0, json_1.enableJsonOutput)();
         }

package/build/commands/observe/metrics.d.ts

@@ -17,5 +17,6 @@ export default class ObserveMetrics extends EasCommand {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
     };
+    private static loggedInOnlyContextDefinition;
     runAsync(): Promise<void>;
 }

package/build/commands/observe/metrics.js

@@ -69,12 +69,25 @@ class ObserveMetrics extends EasCommand_1.default {
         ...this.ContextOptions.ProjectId,
         ...this.ContextOptions.LoggedIn,
     };
+    static loggedInOnlyContextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
     async runAsync() {
         const { flags } = await this.parse(ObserveMetrics);
-        const { projectId: contextProjectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(ObserveMetrics, {
-            nonInteractive: flags['non-interactive'],
-        });
-        const projectId = flags['project-id'] ?? contextProjectId;
+        let projectId;
+        let graphqlClient;
+        if (flags['project-id']) {
+            projectId = flags['project-id'];
+            const ctx = await this.getContextAsync({ contextDefinition: ObserveMetrics.loggedInOnlyContextDefinition }, { nonInteractive: flags['non-interactive'] });
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
+        else {
+            const ctx = await this.getContextAsync(ObserveMetrics, {
+                nonInteractive: flags['non-interactive'],
+            });
+            projectId = ctx.projectId;
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
         if (flags.json) {
             (0, json_1.enableJsonOutput)();
         }
@@ -94,7 +107,7 @@ class ObserveMetrics extends EasCommand_1.default {
             : undefined;
         if (flags.json) {
             const stats = argumentsStat ?? DEFAULT_STATS_JSON;
-            (0, json_1.printJsonOnlyOutput)((0, formatMetrics_1.buildObserveMetricsJson)(metricsMap, metricNames, stats, totalEventCounts));
+            (0, json_1.printJsonOnlyOutput)((0, formatMetrics_1.buildObserveMetricsJson)(metricsMap, metricNames, stats, totalEventCounts, buildNumbersMap, updateIdsMap));
         }
         else {
             const stats = argumentsStat ?? DEFAULT_STATS_TABLE;
@@ -102,7 +115,6 @@ class ObserveMetrics extends EasCommand_1.default {
             log_1.default.log((0, formatMetrics_1.buildObserveMetricsTable)(metricsMap, metricNames, stats, {
                 daysBack,
                 buildNumbersMap,
-                updateIdsMap,
                 totalEventCounts,
             }));
         }

package/build/commands/observe/versions.d.ts

@@ -15,5 +15,6 @@ export default class ObserveVersions extends EasCommand {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
     };
+    private static loggedInOnlyContextDefinition;
     runAsync(): Promise<void>;
 }

package/build/commands/observe/versions.js

@@ -40,12 +40,25 @@ class ObserveVersions extends EasCommand_1.default {
         ...this.ContextOptions.ProjectId,
         ...this.ContextOptions.LoggedIn,
     };
+    static loggedInOnlyContextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
     async runAsync() {
         const { flags } = await this.parse(ObserveVersions);
-        const { projectId: contextProjectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(ObserveVersions, {
-            nonInteractive: flags['non-interactive'],
-        });
-        const projectId = flags['project-id'] ?? contextProjectId;
+        let projectId;
+        let graphqlClient;
+        if (flags['project-id']) {
+            projectId = flags['project-id'];
+            const ctx = await this.getContextAsync({ contextDefinition: ObserveVersions.loggedInOnlyContextDefinition }, { nonInteractive: flags['non-interactive'] });
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
+        else {
+            const ctx = await this.getContextAsync(ObserveVersions, {
+                nonInteractive: flags['non-interactive'],
+            });
+            projectId = ctx.projectId;
+            graphqlClient = ctx.loggedIn.graphqlClient;
+        }
         if (flags.json) {
             (0, json_1.enableJsonOutput)();
         }

package/build/commands/update/insights.d.ts

@@ -0,0 +1,19 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class UpdateInsights extends EasCommand {
+    static description: string;
+    static args: {
+        groupId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios" | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        days: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/update/insights.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const UpdateInsightsQuery_1 = require("../../graphql/queries/UpdateInsightsQuery");
+const timeRange_1 = require("../../insights/timeRange");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const formatInsights_1 = require("../../update/insights/formatInsights");
+const json_1 = require("../../utils/json");
+class UpdateInsights extends EasCommand_1.default {
+    static description = 'display launch, crash, unique-user, and size insights for an update group';
+    static args = {
+        groupId: core_1.Args.string({
+            required: true,
+            description: 'The ID of an update group.',
+        }),
+    };
+    static flags = {
+        platform: core_1.Flags.option({
+            description: 'Filter to a single platform.',
+            options: ['ios', 'android'],
+        })(),
+        days: core_1.Flags.integer({
+            description: `Show insights from the last N days (default ${timeRange_1.INSIGHTS_DEFAULT_DAYS_BACK}, mutually exclusive with --start/--end).`,
+            min: 1,
+            exclusive: ['start', 'end'],
+        }),
+        start: core_1.Flags.string({
+            description: 'Start of insights time range (ISO date).',
+            exclusive: ['days'],
+        }),
+        end: core_1.Flags.string({
+            description: 'End of insights time range (ISO date).',
+            exclusive: ['days'],
+        }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args: { groupId }, flags, } = await this.parse(UpdateInsights);
+        const { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const { loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdateInsights, { nonInteractive });
+        if (json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { daysBack, startTime, endTime } = (0, timeRange_1.resolveInsightsTimeRange)(flags);
+        const allUpdates = await UpdateInsightsQuery_1.UpdateInsightsQuery.viewUpdateGroupInsightsAsync(graphqlClient, {
+            groupId,
+            startTime,
+            endTime,
+        });
+        const updates = flags.platform
+            ? allUpdates.filter(u => u.platform === flags.platform)
+            : allUpdates;
+        if (updates.length === 0) {
+            throw new Error(`Update group "${groupId}" has no ${flags.platform} update (available platforms: ${allUpdates
+                .map(u => u.platform)
+                .sort()
+                .join(', ')}).`);
+        }
+        const summary = (0, formatInsights_1.toUpdateInsightsSummary)(groupId, updates, { startTime, endTime, daysBack });
+        if (json) {
+            (0, json_1.printJsonOnlyOutput)((0, formatInsights_1.buildUpdateInsightsJson)(summary));
+        }
+        else {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log((0, formatInsights_1.buildUpdateInsightsTable)(summary));
+        }
+    }
+}
+exports.default = UpdateInsights;

package/build/commands/update/view.d.ts

@@ -6,6 +6,10 @@ export default class UpdateView extends EasCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        insights: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        days: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;

package/build/commands/update/view.js

@@ -5,8 +5,11 @@ const core_1 = require("@oclif/core");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
+const UpdateInsightsQuery_1 = require("../../graphql/queries/UpdateInsightsQuery");
 const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
+const timeRange_1 = require("../../insights/timeRange");
 const log_1 = tslib_1.__importDefault(require("../../log"));
+const formatInsights_1 = require("../../update/insights/formatInsights");
 const utils_1 = require("../../update/utils");
 const json_1 = require("../../utils/json");
 class UpdateView extends EasCommand_1.default {
@@ -18,25 +21,67 @@ class UpdateView extends EasCommand_1.default {
         }),
     };
     static flags = {
+        insights: core_1.Flags.boolean({
+            description: 'Also show insights (launches, crash rate, unique users, payload size) for the update group.',
+            default: false,
+        }),
+        days: core_1.Flags.integer({
+            description: 'Show insights from the last N days (default 7). Only used with --insights.',
+            min: 1,
+            exclusive: ['start', 'end'],
+        }),
+        start: core_1.Flags.string({
+            description: 'Start of insights time range (ISO date). Only used with --insights.',
+            exclusive: ['days'],
+        }),
+        end: core_1.Flags.string({
+            description: 'End of insights time range (ISO date). Only used with --insights.',
+            exclusive: ['days'],
+        }),
         ...flags_1.EasJsonOnlyFlag,
     };
     static contextDefinition = {
         ...this.ContextOptions.LoggedIn,
     };
     async runAsync() {
-        const { args: { groupId }, flags: { json: jsonFlag }, } = await this.parse(UpdateView);
+        const { args: { groupId }, flags: { json: jsonFlag, insights: insightsFlag, days, start, end }, } = await this.parse(UpdateView);
+        if (!insightsFlag && (days !== undefined || start !== undefined || end !== undefined)) {
+            throw new Error('--days, --start, and --end can only be used with --insights.');
+        }
         const { loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdateView, { nonInteractive: true });
         if (jsonFlag) {
             (0, json_1.enableJsonOutput)();
         }
         const updatesByGroup = await UpdateQuery_1.UpdateQuery.viewUpdateGroupAsync(graphqlClient, { groupId });
+        let insightsSummary = null;
+        if (insightsFlag) {
+            const { daysBack, startTime, endTime } = (0, timeRange_1.resolveInsightsTimeRange)({ days, start, end });
+            const updatesWithInsights = await UpdateInsightsQuery_1.UpdateInsightsQuery.viewUpdateGroupInsightsAsync(graphqlClient, { groupId, startTime, endTime });
+            insightsSummary = (0, formatInsights_1.toUpdateInsightsSummary)(groupId, updatesWithInsights, {
+                startTime,
+                endTime,
+                daysBack,
+            });
+        }
         if (jsonFlag) {
-            (0, json_1.printJsonOnlyOutput)((0, utils_1.getUpdateJsonInfosForUpdates)(updatesByGroup));
+            if (insightsSummary) {
+                (0, json_1.printJsonOnlyOutput)({
+                    updates: (0, utils_1.getUpdateJsonInfosForUpdates)(updatesByGroup),
+                    insights: (0, formatInsights_1.buildUpdateInsightsJson)(insightsSummary),
+                });
+            }
+            else {
+                (0, json_1.printJsonOnlyOutput)((0, utils_1.getUpdateJsonInfosForUpdates)(updatesByGroup));
+            }
         }
         else {
             const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([updatesByGroup]);
             log_1.default.log(chalk_1.default.bold('Update group:'));
             log_1.default.log((0, utils_1.formatUpdateGroup)(updateGroupDescription));
+            if (insightsSummary) {
+                log_1.default.addNewLineIfNone();
+                log_1.default.log((0, formatInsights_1.buildUpdateInsightsTable)(insightsSummary));
+            }
         }
     }
 }

package/build/credentials/ios/appstore/capabilityIdentifiers.js

@@ -34,6 +34,19 @@ async function syncCapabilityIdentifiersForEntitlementsAsync(bundleId, entitleme
     // these are only APPLE_PAY, ICLOUD, APP_GROUPS
     const CapabilityIdMapping = capabilityList_1.CapabilityMapping.filter(capability => capability.capabilityIdModel);
     const updateRequest = [];
+    // Fetch the bundle with its linked capability identifiers to check for already linked identifiers.
+    const bundleWithRelationships = await apple_utils_1.BundleId.infoAsync(bundleId.context, {
+        id: bundleId.id,
+        query: {
+            includes: [
+                'bundleIdCapabilities',
+                'bundleIdCapabilities.appGroups',
+                'bundleIdCapabilities.merchantIds',
+                'bundleIdCapabilities.cloudContainers',
+            ],
+        },
+    });
+    const linkedBundleCapabilities = bundleWithRelationships.attributes.bundleIdCapabilities ?? [];
     // Iterate through the supported capabilities to build the request.
     for (const classifier of CapabilityIdMapping) {
         const CapabilityModel = classifier.capabilityIdModel;
@@ -57,12 +70,24 @@ async function syncCapabilityIdentifiersForEntitlementsAsync(bundleId, entitleme
         const capabilityIds = [...new Set(entitlementValue)];
         // Get a list of all of the capability IDs that are already created on the server.
         const existingIds = await CapabilityModel.getAsync(bundleId.context);
+        // Opaque ids of identifiers already linked to this capability.
+        const remoteLinkedIds = linkedBundleCapabilities.find(c => c.isType(classifier.capability))
+            ?.attributes;
+        const alreadyLinkedOpaqueIds = new Set((remoteLinkedIds?.[CapabilityModel.type] ?? []).map(model => model.id));
         // A list of server IDs for linking.
         const capabilityIdOpaqueIds = [];
-        const capabilitiesWithoutRemoteModels = capabilityIds.filter(localId => existingIds.find(model => model.attributes.identifier === localId) === undefined);
         // Iterate through all the local IDs and see if they exist on the server.
-        for (const localId of capabilitiesWithoutRemoteModels) {
-            let remoteIdModel = undefined;
+        for (const localId of capabilityIds) {
+            let remoteIdModel = existingIds.find(model => model.attributes.identifier === localId);
+            // Identifier already exists.
+            if (remoteIdModel) {
+                if (!alreadyLinkedOpaqueIds.has(remoteIdModel.id)) {
+                    // Link the existing identifier to this bundle.
+                    linkedIds.push(remoteIdModel.attributes.identifier);
+                    capabilityIdOpaqueIds.push(remoteIdModel.id);
+                }
+                continue;
+            }
             if (log_1.default.isDebug) {
                 log_1.default.log(`Creating capability ID: ${localId} (${CapabilityModel.type})`);
             }

package/build/graphql/client.d.ts

@@ -1,3 +1,16 @@
 import { CombinedError as GraphqlError, OperationResult } from '@urql/core';
+export declare const EAS_CLI_UPGRADE_REQUIRED_ERROR_CODE = "EAS_CLI_UPGRADE_REQUIRED";
 export declare function withErrorHandlingAsync<T>(promise: Promise<OperationResult<T>>): Promise<T>;
+/**
+ * Wraps `withErrorHandlingAsync` for queries that hit endpoints which may evolve in
+ * ways that require a newer eas-cli. The server signals this by returning a GraphQL
+ * error with `extensions.errorCode === EAS_CLI_UPGRADE_REQUIRED`. As a fallback we
+ * also detect schema validation errors of the form `Cannot query field "X" on type "Y"`,
+ * which surface when a field has been removed without a coded error.
+ *
+ * In either case we re-throw an `EasCommandError` instructing the user to upgrade.
+ */
+export declare function withUpgradeRequiredErrorHandlingAsync<T>(promise: Promise<OperationResult<T>>, { featureName }: {
+    featureName: string;
+}): Promise<T>;
 export { GraphqlError };