eas-cli 18.7.0 → 18.8.1

package/build/build/utils/url.d.ts

@@ -5,5 +5,11 @@ export declare function getArtifactUrl(artifactId: string): string;
 export declare function getInternalDistributionInstallUrl(build: BuildFragment): string;
 export declare function getUpdateGroupUrl(accountName: string, projectName: string, updateGroupId: string): string;
 export declare function getWorkflowRunUrl(accountName: string, projectName: string, workflowRunId: string): string;
+/**
+ * @deprecated Links to the raw job-run page; prefer a higher-level URL (e.g. the workflow run
+ * or the feature-specific dashboard) that gives users more context. Use this only for internal
+ * tooling where no richer URL exists.
+ */
+export declare function getBareJobRunUrl(accountName: string, projectName: string, jobRunId: string): string;
 export declare function getProjectGitHubSettingsUrl(accountName: string, projectName: string): string;
 export declare function getHostingDeploymentsUrl(accountName: string, projectName: string): string;

package/build/build/utils/url.js

@@ -6,6 +6,7 @@ exports.getArtifactUrl = getArtifactUrl;
 exports.getInternalDistributionInstallUrl = getInternalDistributionInstallUrl;
 exports.getUpdateGroupUrl = getUpdateGroupUrl;
 exports.getWorkflowRunUrl = getWorkflowRunUrl;
+exports.getBareJobRunUrl = getBareJobRunUrl;
 exports.getProjectGitHubSettingsUrl = getProjectGitHubSettingsUrl;
 exports.getHostingDeploymentsUrl = getHostingDeploymentsUrl;
 const tslib_1 = require("tslib");
@@ -38,6 +39,14 @@ function getUpdateGroupUrl(accountName, projectName, updateGroupId) {
 function getWorkflowRunUrl(accountName, projectName, workflowRunId) {
     return new URL(`/accounts/${encodeURIComponent(accountName)}/projects/${encodeURIComponent(projectName)}/workflows/${workflowRunId}`, (0, api_1.getExpoWebsiteBaseUrl)()).toString();
 }
+/**
+ * @deprecated Links to the raw job-run page; prefer a higher-level URL (e.g. the workflow run
+ * or the feature-specific dashboard) that gives users more context. Use this only for internal
+ * tooling where no richer URL exists.
+ */
+function getBareJobRunUrl(accountName, projectName, jobRunId) {
+    return new URL(`/accounts/${encodeURIComponent(accountName)}/projects/${encodeURIComponent(projectName)}/job-runs/${encodeURIComponent(jobRunId)}`, (0, api_1.getExpoWebsiteBaseUrl)()).toString();
+}
 function getProjectGitHubSettingsUrl(accountName, projectName) {
     return new URL(`/accounts/${encodeURIComponent(accountName)}/projects/${encodeURIComponent(projectName)}/github`, (0, api_1.getExpoWebsiteBaseUrl)()).toString();
 }

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/simulator/start.d.ts

@@ -0,0 +1,16 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class SimulatorStart extends EasCommand {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios", import("@oclif/core/lib/interfaces").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'package-version': 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/simulator/start.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const generated_1 = require("../../graphql/generated");
+const DeviceRunSessionMutation_1 = require("../../graphql/mutations/DeviceRunSessionMutation");
+const DeviceRunSessionQuery_1 = require("../../graphql/queries/DeviceRunSessionQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const promise_1 = require("../../utils/promise");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const POLL_INTERVAL_MS = 5_000; // 5 seconds
+const POLL_TIMEOUT_MS = 15 * 60 * 1_000; // 15 minutes
+// Mapping enum → CLI flag value. Declared as Record<DeviceRunSessionType, string>
+// so adding a new enum value in codegen fails the build until it is wired up here.
+const DEVICE_RUN_SESSION_TYPE_FLAG_VALUES = {
+    [generated_1.DeviceRunSessionType.AgentDevice]: 'agent-device',
+};
+const DEVICE_RUN_SESSION_TYPE_BY_FLAG_VALUE = Object.fromEntries(Object.entries(DEVICE_RUN_SESSION_TYPE_FLAG_VALUES).map(([type, value]) => [value, type]));
+class SimulatorStart extends EasCommand_1.default {
+    static hidden = true;
+    static description = '[EXPERIMENTAL] start a remote simulator session on EAS and get the credentials to connect to it with the CLI tool of your choice';
+    static flags = {
+        platform: core_1.Flags.option({
+            description: 'Device platform',
+            options: ['android', 'ios'],
+            required: true,
+        })(),
+        type: core_1.Flags.option({
+            description: 'Type of device run session to create',
+            options: Object.values(DEVICE_RUN_SESSION_TYPE_FLAG_VALUES),
+            default: DEVICE_RUN_SESSION_TYPE_FLAG_VALUES[generated_1.DeviceRunSessionType.AgentDevice],
+        })(),
+        'package-version': core_1.Flags.string({
+            description: 'Version of the package backing the device run session (e.g. "0.1.3-alpha.3"). Defaults to "latest" when omitted.',
+        }),
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(SimulatorStart);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(SimulatorStart, {
+            nonInteractive: flags['non-interactive'],
+        });
+        const platform = flags.platform === 'android' ? generated_1.AppPlatform.Android : generated_1.AppPlatform.Ios;
+        const createSpinner = (0, ora_1.ora)('🚀 Creating device run session').start();
+        let deviceRunSessionId;
+        try {
+            const session = await DeviceRunSessionMutation_1.DeviceRunSessionMutation.createDeviceRunSessionAsync(graphqlClient, {
+                appId: projectId,
+                platform,
+                type: DEVICE_RUN_SESSION_TYPE_BY_FLAG_VALUE[flags.type],
+                packageVersion: flags['package-version'],
+            });
+            deviceRunSessionId = session.id;
+            const jobRunId = (0, nullthrows_1.default)(session.turtleJobRun?.id, 'Expected device run session to start');
+            const jobRunUrl = (0, url_1.getBareJobRunUrl)(session.app.ownerAccount.name, session.app.slug, jobRunId);
+            createSpinner.succeed(`Device run session created (id: ${deviceRunSessionId}) ${(0, log_1.link)(jobRunUrl)}`);
+        }
+        catch (err) {
+            createSpinner.fail('Failed to create device run session');
+            throw err;
+        }
+        const checkReadiness = getReadinessCheckerForType(flags.type);
+        const pollSpinner = (0, ora_1.ora)(`⏳ Waiting for ${flags.type} daemon to start`).start();
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        let result = { ready: false };
+        try {
+            while (Date.now() < deadline) {
+                const session = await DeviceRunSessionQuery_1.DeviceRunSessionQuery.byIdAsync(graphqlClient, deviceRunSessionId);
+                if (session.status === generated_1.DeviceRunSessionStatus.Errored ||
+                    session.status === generated_1.DeviceRunSessionStatus.Stopped) {
+                    throw new Error(`Device run session ${deviceRunSessionId} ${session.status.toLowerCase()} before the ${flags.type} daemon was ready.`);
+                }
+                const jobRunStatus = session.turtleJobRun?.status;
+                if (jobRunStatus === generated_1.JobRunStatus.Errored ||
+                    jobRunStatus === generated_1.JobRunStatus.Canceled ||
+                    jobRunStatus === generated_1.JobRunStatus.Finished) {
+                    throw new Error(`Turtle job run for device run session ${deviceRunSessionId} ${jobRunStatus.toLowerCase()} before the ${flags.type} daemon was ready.`);
+                }
+                const logMessages = await fetchLogMessagesAsync(session.turtleJobRun?.logFileUrls ?? []);
+                result = checkReadiness(logMessages);
+                if (result.ready) {
+                    pollSpinner.succeed(`🎉 ${flags.type} daemon is ready`);
+                    break;
+                }
+                await (0, promise_1.sleepAsync)(POLL_INTERVAL_MS);
+            }
+        }
+        catch (err) {
+            pollSpinner.fail(`Failed while polling for ${flags.type} daemon logs`);
+            throw err;
+        }
+        if (!result.ready) {
+            pollSpinner.fail(`Timed out waiting for ${flags.type} daemon to start`);
+            throw new Error(`Timed out after ${Math.round(POLL_TIMEOUT_MS / 1000)}s waiting for ${flags.type} daemon to start.`);
+        }
+        log_1.default.newLine();
+        log_1.default.log(`🔑 Run the following in your shell to attach to ${flags.type}:`);
+        log_1.default.newLine();
+        log_1.default.log(result.message);
+    }
+}
+exports.default = SimulatorStart;
+function getReadinessCheckerForType(type) {
+    switch (type) {
+        case DEVICE_RUN_SESSION_TYPE_FLAG_VALUES[generated_1.DeviceRunSessionType.AgentDevice]:
+            return checkAgentDeviceReadiness;
+        default:
+            throw new Error(`Unsupported device run session type: ${type}`);
+    }
+}
+const AGENT_DEVICE_BASE_URL_ENV_VAR = 'AGENT_DEVICE_DAEMON_BASE_URL';
+const AGENT_DEVICE_AUTH_TOKEN_ENV_VAR = 'AGENT_DEVICE_DAEMON_AUTH_TOKEN';
+function checkAgentDeviceReadiness(logMessages) {
+    let baseUrl;
+    let authToken;
+    for (const msg of logMessages) {
+        baseUrl = baseUrl ?? extractExportedEnvValue(msg, AGENT_DEVICE_BASE_URL_ENV_VAR);
+        authToken = authToken ?? extractExportedEnvValue(msg, AGENT_DEVICE_AUTH_TOKEN_ENV_VAR);
+        if (baseUrl && authToken) {
+            break;
+        }
+    }
+    if (baseUrl && authToken) {
+        return {
+            ready: true,
+            message: [
+                `export ${AGENT_DEVICE_BASE_URL_ENV_VAR}='${baseUrl}'`,
+                `export ${AGENT_DEVICE_AUTH_TOKEN_ENV_VAR}='${authToken}'`,
+            ].join('\n'),
+        };
+    }
+    return { ready: false };
+}
+async function fetchLogMessagesAsync(logUrls) {
+    const messages = [];
+    for (const url of logUrls) {
+        const text = await fetchLogTextAsync(url);
+        if (!text) {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            messages.push(extractLogMessage(line));
+        }
+    }
+    return messages;
+}
+async function fetchLogTextAsync(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return undefined;
+        }
+        return await response.text();
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractLogMessage(line) {
+    // Turtle job run logs are JSONL (bunyan-shaped), e.g.
+    //   {"msg":"export FOO=\"bar\"","time":"...","logId":"..."}
+    // Fall back to the raw line if it's not JSON or doesn't have a string msg.
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) {
+        return line;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && 'msg' in parsed) {
+            const msg = parsed.msg;
+            if (typeof msg === 'string') {
+                return msg;
+            }
+        }
+    }
+    catch {
+        // not JSON, fall through
+    }
+    return line;
+}
+function extractExportedEnvValue(text, varName) {
+    // Matches: export NAME=value | export NAME="value" | export NAME='value'
+    const pattern = new RegExp(`export\\s+${escapeRegExp(varName)}=(?:"([^"]*)"|'([^']*)'|(\\S+))`);
+    const match = pattern.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    return match[1] ?? match[2] ?? match[3];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

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