eas-cli 18.4.0 → 18.6.0

package/build/observe/formatMetrics.d.ts

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

package/build/observe/formatMetrics.js

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

package/build/observe/formatVersions.d.ts

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

package/build/observe/formatVersions.js

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

package/build/observe/metricNames.d.ts

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

package/build/observe/metricNames.js

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

package/build/observe/startAndEndTime.d.ts

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

package/build/observe/startAndEndTime.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DAYS_BACK = void 0;
+exports.startAndEndTime = startAndEndTime;
+exports.resolveTimeRange = resolveTimeRange;
+const fetchMetrics_1 = require("./fetchMetrics");
+exports.DEFAULT_DAYS_BACK = 60;
+function startAndEndTime({ daysBack, start, end, }) {
+    let startTime;
+    let endTime;
+    if (daysBack) {
+        endTime = new Date().toISOString();
+        startTime = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1000).toISOString();
+    }
+    else {
+        endTime = end ?? new Date().toISOString();
+        startTime =
+            start ?? new Date(Date.now() - exports.DEFAULT_DAYS_BACK * 24 * 60 * 60 * 1000).toISOString();
+    }
+    return { startTime, endTime };
+}
+function resolveTimeRange(flags) {
+    if (flags.start) {
+        (0, fetchMetrics_1.validateDateFlag)(flags.start, '--start');
+    }
+    if (flags.end) {
+        (0, fetchMetrics_1.validateDateFlag)(flags.end, '--end');
+    }
+    const daysBack = flags.days ?? (flags.start ? undefined : exports.DEFAULT_DAYS_BACK);
+    const { startTime, endTime } = startAndEndTime({
+        daysBack,
+        start: flags.start,
+        end: flags.end,
+    });
+    return { daysBack, startTime, endTime };
+}

package/build/project/projectUtils.d.ts

@@ -1,8 +1,6 @@
 import { ExpoConfig } from '@expo/config';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { AccountFragment } from '../graphql/generated';
-import { Actor } from '../user/User';
-export declare function getUsernameForBuildMetadataAndBuildJob(user: Actor): string | undefined;
 /**
  * Return a useful name describing the project config.
  * - dynamic: app.config.js

package/build/project/projectUtils.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUsernameForBuildMetadataAndBuildJob = getUsernameForBuildMetadataAndBuildJob;
 exports.getProjectConfigDescription = getProjectConfigDescription;
 exports.isExpoUpdatesInstalled = isExpoUpdatesInstalled;
 exports.isExpoNotificationsInstalled = isExpoNotificationsInstalled;
@@ -26,17 +25,6 @@ const api_1 = require("../api");
 const AppQuery_1 = require("../graphql/queries/AppQuery");
 const log_1 = tslib_1.__importStar(require("../log"));
 const expoCli_1 = require("../utils/expoCli");
-function getUsernameForBuildMetadataAndBuildJob(user) {
-    switch (user.__typename) {
-        case 'User':
-            return user.username;
-        case 'SSOUser':
-            return user.username;
-        case 'Robot':
-            // robot users don't have usernames
-            return undefined;
-    }
-}
 /**
  * Return a useful name describing the project config.
  * - dynamic: app.config.js

package/build/project/workflow.js

@@ -44,7 +44,7 @@ async function hasIgnoredIosProjectAsync(projectDir, vcsClient) {
         const pbxProjectPath = config_plugins_1.IOSConfig.Paths.getPBXProjectPath(projectDir);
         return await vcsClient.isFileIgnoredAsync(path_1.default.relative(vcsRootPath, pbxProjectPath));
     }
-    finally {
+    catch {
         return false;
     }
 }

package/build/sentry.d.ts

@@ -0,0 +1,2 @@
+import * as Sentry from '@sentry/node';
+export default Sentry;

package/build/sentry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Sentry = tslib_1.__importStar(require("@sentry/node"));
+const easCli_1 = require("./utils/easCli");
+Sentry.init({
+    dsn: process.env.EAS_CLI_SENTRY_DSN,
+    enabled: !!process.env.EAS_CLI_SENTRY_DSN,
+    environment: getSentryEnvironment(),
+    release: easCli_1.easCliVersion ? `eas-cli@${easCli_1.easCliVersion}` : undefined,
+});
+Sentry.setTag('source', 'eas-cli');
+function getSentryEnvironment() {
+    if (process.env.EXPO_LOCAL) {
+        return 'local';
+    }
+    else if (process.env.EXPO_STAGING) {
+        return 'staging';
+    }
+    return 'production';
+}
+exports.default = Sentry;

package/build/update/utils.d.ts

@@ -1,9 +1,9 @@
 import { ExpoConfig } from '@expo/config';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
-import { AppPlatform, Robot, SsoUser, Update, UpdateBranchFragment, UpdateFragment, UpdatePublishMutation, User } from '../graphql/generated';
+import { AppPlatform, PartnerActor, Robot, SsoUser, Update, UpdateBranchFragment, UpdateFragment, UpdatePublishMutation, User } from '../graphql/generated';
 import { RequestedPlatform } from '../platform';
 export type FormatUpdateParameter = Pick<Update, 'id' | 'createdAt' | 'message'> & {
-    actor?: Pick<Robot, '__typename' | 'firstName'> | Pick<User, '__typename' | 'username'> | Pick<SsoUser, '__typename' | 'username'> | null;
+    actor?: Pick<Robot, '__typename' | 'firstName'> | Pick<User, '__typename' | 'username'> | Pick<SsoUser, '__typename' | 'username'> | Pick<PartnerActor, '__typename' | 'username'> | null;
 };
 export type UpdateJsonInfo = {
     branch: string;

package/build/update/utils.js

@@ -110,6 +110,7 @@ function formatUpdateTitle(update) {
     let actorName;
     switch (actor?.__typename) {
         case 'User':
+        case 'PartnerActor':
         case 'SSOUser': {
             actorName = actor.username;
             break;

package/build/user/SessionManager.js

@@ -51,6 +51,17 @@ class SessionManager {
         });
     }
     async logoutAsync() {
+        const sessionSecret = this.getSessionSecret();
+        if (sessionSecret) {
+            const apiV2Client = new api_1.ApiV2Client({ accessToken: null, sessionSecret });
+            try {
+                await apiV2Client.postAsync('auth/logout', { body: {} });
+            }
+            catch (e) {
+                // Best-effort: clear the local session even if the server request fails
+                log_1.default.debug('Failed to invalidate session secret on server:', e);
+            }
+        }
         this.currentActor = undefined;
         await this.setSessionAsync(undefined);
     }

package/build/user/User.d.ts

@@ -1,9 +1,9 @@
-import { CurrentUserQuery, Robot, SsoUser, User } from '../graphql/generated';
+import { CurrentUserQuery, PartnerActor, Robot, SsoUser, User } from '../graphql/generated';
 export type Actor = NonNullable<CurrentUserQuery['meActor']>;
 /**
  * Resolve the name of the actor, either normal user, sso user or robot user.
  * This should be used whenever the "current user" needs to be displayed.
  * The display name CANNOT be used as project owner.
  */
-export declare function getActorDisplayName(actor?: Pick<Robot, '__typename' | 'firstName'> | Pick<User, '__typename' | 'username'> | Pick<SsoUser, '__typename' | 'username'> | null): string;
+export declare function getActorDisplayName(actor?: Pick<Robot, '__typename' | 'firstName'> | Pick<User, '__typename' | 'username'> | Pick<SsoUser, '__typename' | 'username'> | Pick<PartnerActor, '__typename' | 'username'> | null): string;
 export declare function getActorUsername(actor?: Actor): string | null;

package/build/user/User.js

@@ -15,6 +15,8 @@ function getActorDisplayName(actor) {
             return actor.firstName ? `${actor.firstName} (robot)` : 'robot';
         case 'SSOUser':
             return actor.username;
+        case 'PartnerActor':
+            return actor.username;
         case undefined:
             return 'unknown';
     }
@@ -23,6 +25,7 @@ function getActorUsername(actor) {
     switch (actor?.__typename) {
         case 'User':
         case 'SSOUser':
+        case 'PartnerActor':
             return actor.username;
         case 'Robot':
         case undefined: