@donotuse/eas-cli 18.5.0-rc.1

package/build/user/SessionManager.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSecondFactorDeviceMethod = void 0;
+const tslib_1 = require("tslib");
+const json_file_1 = tslib_1.__importDefault(require("@expo/json-file"));
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const fetchSessionSecretAndUser_1 = require("./fetchSessionSecretAndUser");
+const fetchSessionSecretAndUserFromBrowserAuthFlow_1 = require("./fetchSessionSecretAndUserFromBrowserAuthFlow");
+const ApiV2Error_1 = require("../ApiV2Error");
+const api_1 = require("../api");
+const createGraphqlClient_1 = require("../commandUtils/context/contextUtils/createGraphqlClient");
+const UserQuery_1 = require("../graphql/queries/UserQuery");
+const log_1 = tslib_1.__importStar(require("../log"));
+const prompts_1 = require("../prompts");
+const paths_1 = require("../utils/paths");
+var UserSecondFactorDeviceMethod;
+(function (UserSecondFactorDeviceMethod) {
+    UserSecondFactorDeviceMethod["AUTHENTICATOR"] = "authenticator";
+    UserSecondFactorDeviceMethod["SMS"] = "sms";
+})(UserSecondFactorDeviceMethod || (exports.UserSecondFactorDeviceMethod = UserSecondFactorDeviceMethod = {}));
+class SessionManager {
+    analytics;
+    currentActor;
+    constructor(analytics) {
+        this.analytics = analytics;
+    }
+    getAccessToken() {
+        return process.env.EXPO_TOKEN ?? null;
+    }
+    getSessionSecret() {
+        return this.getSession()?.sessionSecret ?? null;
+    }
+    getSession() {
+        try {
+            return json_file_1.default.read((0, paths_1.getStateJsonPath)())?.auth ?? null;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async setSessionAsync(sessionData) {
+        await json_file_1.default.setAsync((0, paths_1.getStateJsonPath)(), 'auth', sessionData, {
+            default: {},
+            ensureDir: true,
+        });
+    }
+    async logoutAsync() {
+        this.currentActor = undefined;
+        await this.setSessionAsync(undefined);
+    }
+    async getUserAsync() {
+        if (!this.currentActor && (this.getAccessToken() || this.getSessionSecret())) {
+            const authenticationInfo = {
+                accessToken: this.getAccessToken(),
+                sessionSecret: this.getSessionSecret(),
+            };
+            const actor = await UserQuery_1.UserQuery.currentUserAsync((0, createGraphqlClient_1.createGraphqlClient)(authenticationInfo));
+            this.currentActor = actor ?? undefined;
+            if (actor) {
+                this.analytics.setActor(actor);
+            }
+        }
+        return this.currentActor;
+    }
+    /**
+     * Ensure that there is a logged-in actor. Show a login prompt if not.
+     *
+     * @param nonInteractive whether the log-in prompt if logged-out should be interactive
+     * @returns logged-in Actor
+     */
+    async ensureLoggedInAsync({ nonInteractive, }) {
+        let actor;
+        try {
+            actor = await this.getUserAsync();
+        }
+        catch { }
+        if (!actor) {
+            log_1.default.warn('An Expo user account is required to proceed.');
+            await this.showLoginPromptAsync({ nonInteractive, printNewLine: true });
+            actor = await this.getUserAsync();
+        }
+        const accessToken = this.getAccessToken();
+        const authenticationInfo = accessToken
+            ? {
+                accessToken,
+                sessionSecret: null,
+            }
+            : {
+                accessToken: null,
+                sessionSecret: (0, nullthrows_1.default)(this.getSessionSecret()),
+            };
+        return { actor: (0, nullthrows_1.default)(actor), authenticationInfo };
+    }
+    /**
+     * Prompt the user to log in.
+     *
+     * @deprecated Should not be used outside of context functions, except in the AccountLogin command.
+     */
+    async showLoginPromptAsync({ nonInteractive = false, printNewLine = false, sso = false, browser = false, } = {}) {
+        if (nonInteractive) {
+            core_1.Errors.error(`Either log in with ${chalk_1.default.bold('eas login')} or set the ${chalk_1.default.bold('EXPO_TOKEN')} environment variable if you're using EAS CLI on CI (${(0, log_1.learnMore)('https://docs.expo.dev/accounts/programmatic-access/', { dim: false })})`);
+        }
+        if (printNewLine) {
+            log_1.default.newLine();
+        }
+        if (sso || browser) {
+            await this.browserLoginAsync({ sso });
+            return;
+        }
+        log_1.default.log(`Log in to EAS with email or username (exit and run ${chalk_1.default.bold('eas login --help')} to see other login options)`);
+        const { username, password } = await (0, prompts_1.promptAsync)([
+            {
+                type: 'text',
+                name: 'username',
+                message: 'Email or username',
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Password',
+            },
+        ]);
+        try {
+            await this.loginAsync({
+                username,
+                password,
+            });
+        }
+        catch (e) {
+            if (e instanceof ApiV2Error_1.ApiV2Error && e.expoApiV2ErrorCode === 'ONE_TIME_PASSWORD_REQUIRED') {
+                await this.retryUsernamePasswordAuthWithOTPAsync(username, password, e.expoApiV2ErrorMetadata);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async browserLoginAsync({ sso = false }) {
+        const { sessionSecret, id, username } = await (0, fetchSessionSecretAndUserFromBrowserAuthFlow_1.fetchSessionSecretAndUserFromBrowserAuthFlowAsync)({ sso });
+        await this.setSessionAsync({
+            sessionSecret,
+            userId: id,
+            username,
+            currentConnection: 'Browser-Flow-Authentication',
+        });
+    }
+    async loginAsync(input) {
+        const { sessionSecret, id, username } = await (0, fetchSessionSecretAndUser_1.fetchSessionSecretAndUserAsync)(input);
+        await this.setSessionAsync({
+            sessionSecret,
+            userId: id,
+            username,
+            currentConnection: 'Username-Password-Authentication',
+        });
+    }
+    /**
+     * Prompt for an OTP with the option to cancel the question by answering empty (pressing return key).
+     */
+    async promptForOTPAsync(cancelBehavior) {
+        const enterMessage = cancelBehavior === 'cancel'
+            ? `press ${chalk_1.default.bold('Enter')} to cancel`
+            : `press ${chalk_1.default.bold('Enter')} for more options`;
+        const { otp } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'otp',
+            message: `One-time password or backup code (${enterMessage}):`,
+        });
+        if (!otp) {
+            return null;
+        }
+        return otp;
+    }
+    /**
+     * Prompt for user to choose a backup OTP method. If selected method is SMS, a request
+     * for a new OTP will be sent to that method. Then, prompt for the OTP, and retry the user login.
+     */
+    async promptForBackupOTPAsync(username, password, secondFactorDevices) {
+        const nonPrimarySecondFactorDevices = secondFactorDevices.filter(device => !device.is_primary);
+        if (nonPrimarySecondFactorDevices.length === 0) {
+            throw new Error('No other second-factor devices set up. Ensure you have set up and certified a backup device.');
+        }
+        const hasAuthenticatorSecondFactorDevice = nonPrimarySecondFactorDevices.find(device => device.method === UserSecondFactorDeviceMethod.AUTHENTICATOR);
+        const smsNonPrimarySecondFactorDevices = nonPrimarySecondFactorDevices.filter(device => device.method === UserSecondFactorDeviceMethod.SMS);
+        const authenticatorChoiceSentinel = -1;
+        const cancelChoiceSentinel = -2;
+        const deviceChoices = smsNonPrimarySecondFactorDevices.map((device, idx) => ({
+            title: device.sms_phone_number,
+            value: idx,
+        }));
+        if (hasAuthenticatorSecondFactorDevice) {
+            deviceChoices.push({
+                title: 'Authenticator',
+                value: authenticatorChoiceSentinel,
+            });
+        }
+        deviceChoices.push({
+            title: 'Cancel',
+            value: cancelChoiceSentinel,
+        });
+        const selectedValue = await (0, prompts_1.selectAsync)('Select a second-factor device:', deviceChoices);
+        if (selectedValue === cancelChoiceSentinel) {
+            return null;
+        }
+        else if (selectedValue === authenticatorChoiceSentinel) {
+            return await this.promptForOTPAsync('cancel');
+        }
+        const device = smsNonPrimarySecondFactorDevices[selectedValue];
+        // this is a logged-out endpoint
+        const apiV2Client = new api_1.ApiV2Client({ accessToken: null, sessionSecret: null });
+        await apiV2Client.postAsync('auth/send-sms-otp', {
+            body: {
+                username,
+                password,
+                secondFactorDeviceID: device.id,
+            },
+        });
+        return await this.promptForOTPAsync('cancel');
+    }
+    /**
+     * Handle the special case error indicating that a second-factor is required for
+     * authentication.
+     *
+     * There are three cases we need to handle:
+     * 1. User's primary second-factor device was SMS, OTP was automatically sent by the server to that
+     *    device already. In this case we should just prompt for the SMS OTP (or backup code), which the
+     *    user should be receiving shortly. We should give the user a way to cancel and the prompt and move
+     *    to case 3 below.
+     * 2. User's primary second-factor device is authenticator. In this case we should prompt for authenticator
+     *    OTP (or backup code) and also give the user a way to cancel and move to case 3 below.
+     * 3. User doesn't have a primary device or doesn't have access to their primary device. In this case
+     *    we should show a picker of the SMS devices that they can have an OTP code sent to, and when
+     *    the user picks one we show a prompt() for the sent OTP.
+     */
+    async retryUsernamePasswordAuthWithOTPAsync(username, password, metadata) {
+        const { secondFactorDevices, smsAutomaticallySent } = metadata;
+        (0, assert_1.default)(secondFactorDevices !== undefined && smsAutomaticallySent !== undefined, `Malformed OTP error metadata: ${metadata}`);
+        const primaryDevice = secondFactorDevices.find(device => device.is_primary);
+        let otp = null;
+        if (smsAutomaticallySent) {
+            (0, assert_1.default)(primaryDevice, 'OTP should only automatically be sent when there is a primary device');
+            log_1.default.log(`One-time password was sent to the phone number ending in ${primaryDevice.sms_phone_number}.`);
+            otp = await this.promptForOTPAsync('menu');
+        }
+        if (primaryDevice?.method === UserSecondFactorDeviceMethod.AUTHENTICATOR) {
+            log_1.default.log('One-time password from authenticator required.');
+            otp = await this.promptForOTPAsync('menu');
+        }
+        // user bailed on case 1 or 2, wants to move to case 3
+        if (!otp) {
+            otp = await this.promptForBackupOTPAsync(username, password, secondFactorDevices);
+        }
+        if (!otp) {
+            throw new Error('Cancelled login');
+        }
+        await this.loginAsync({
+            username,
+            password,
+            otp,
+        });
+    }
+}
+exports.default = SessionManager;

package/build/user/User.d.ts

@@ -0,0 +1,9 @@
+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'> | Pick<PartnerActor, '__typename' | 'username'> | null): string;
+export declare function getActorUsername(actor?: Actor): string | null;

package/build/user/User.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActorDisplayName = getActorDisplayName;
+exports.getActorUsername = getActorUsername;
+/**
+ * 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.
+ */
+function getActorDisplayName(actor) {
+    switch (actor?.__typename) {
+        case 'User':
+            return actor.username;
+        case 'Robot':
+            return actor.firstName ? `${actor.firstName} (robot)` : 'robot';
+        case 'SSOUser':
+            return actor.username;
+        case 'PartnerActor':
+            return actor.username;
+        case undefined:
+            return 'unknown';
+    }
+}
+function getActorUsername(actor) {
+    switch (actor?.__typename) {
+        case 'User':
+        case 'SSOUser':
+        case 'PartnerActor':
+            return actor.username;
+        case 'Robot':
+        case undefined:
+            return null;
+    }
+}

package/build/user/UserSettings.d.ts

@@ -0,0 +1,10 @@
+import JsonFile from '@expo/json-file';
+export type UserSettingsData = {
+    appleId?: string;
+    amplitudeDeviceId?: string;
+    amplitudeEnabled?: boolean;
+    analyticsDeviceId?: string;
+    analyticsEnabled?: boolean;
+};
+declare const UserSettings: JsonFile<UserSettingsData>;
+export default UserSettings;

package/build/user/UserSettings.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const json_file_1 = tslib_1.__importDefault(require("@expo/json-file"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const paths_1 = require("../utils/paths");
+const SETTINGS_FILE_PATH = path_1.default.join((0, paths_1.getConfigDirectory)(), 'user-settings.json');
+const UserSettings = new json_file_1.default(SETTINGS_FILE_PATH, {
+    jsonParseErrorDefault: {},
+    cantReadFileDefault: {},
+    ensureDir: true,
+});
+exports.default = UserSettings;

package/build/user/actions.d.ts

@@ -0,0 +1,3 @@
+import { Actor } from './User';
+import { AccountFragment } from '../graphql/generated';
+export declare function ensureActorHasPrimaryAccount(user: Actor): AccountFragment;

package/build/user/actions.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureActorHasPrimaryAccount = ensureActorHasPrimaryAccount;
+function ensureActorHasPrimaryAccount(user) {
+    if (user.__typename === 'User' || user.__typename === 'SSOUser') {
+        return user.primaryAccount;
+    }
+    throw new Error('This action is not supported for robot users.');
+}

package/build/user/expoBrowserAuthFlowLauncher.d.ts

@@ -0,0 +1,3 @@
+export declare function getSessionUsingBrowserAuthFlowAsync({ sso }: {
+    sso?: boolean | undefined;
+}): Promise<string>;

package/build/user/expoBrowserAuthFlowLauncher.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionUsingBrowserAuthFlowAsync = getSessionUsingBrowserAuthFlowAsync;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const better_opn_1 = tslib_1.__importDefault(require("better-opn"));
+const http_1 = tslib_1.__importDefault(require("http"));
+const querystring_1 = tslib_1.__importDefault(require("querystring"));
+const api_1 = require("../api");
+const log_1 = tslib_1.__importDefault(require("../log"));
+async function getSessionUsingBrowserAuthFlowAsync({ sso = false }) {
+    const scheme = 'http';
+    const hostname = 'localhost';
+    const path = '/auth/callback';
+    const expoWebsiteUrl = (0, api_1.getExpoWebsiteBaseUrl)();
+    const buildExpoLoginUrl = (port, sso) => {
+        const params = querystring_1.default.stringify({
+            confirm_account: true,
+            app_redirect_uri: `${scheme}://${hostname}:${port}${path}`,
+        });
+        return `${expoWebsiteUrl}${sso ? '/sso-login' : '/login'}?${params}`;
+    };
+    // Start server and begin auth flow
+    const executeAuthFlow = () => {
+        return new Promise(async (resolve, reject) => {
+            const connections = new Set();
+            const server = http_1.default.createServer((request, response) => {
+                const redirectAndCleanup = (result) => {
+                    const redirectUrl = `${expoWebsiteUrl}/oauth/expo-cli?result=${result}`;
+                    response.writeHead(302, { Location: redirectUrl });
+                    response.end();
+                    server.close();
+                    for (const connection of connections) {
+                        connection.destroy();
+                    }
+                };
+                try {
+                    if (!(request.method === 'GET' && request.url?.includes('/auth/callback'))) {
+                        throw new Error('Unexpected login response.');
+                    }
+                    const url = new URL(request.url, `http:${request.headers.host}`);
+                    const sessionSecret = url.searchParams.get('session_secret');
+                    if (!sessionSecret) {
+                        throw new Error('Request missing session_secret search parameter.');
+                    }
+                    resolve(sessionSecret);
+                    redirectAndCleanup('success');
+                }
+                catch (error) {
+                    redirectAndCleanup('error');
+                    reject(error);
+                }
+            });
+            server.listen(0, hostname, () => {
+                log_1.default.log('Waiting for browser login...');
+                const address = server.address();
+                (0, assert_1.default)(address !== null && typeof address === 'object', 'Server address and port should be set after listening has begun');
+                const port = address.port;
+                const authorizeUrl = buildExpoLoginUrl(port, sso);
+                log_1.default.log(`If your browser doesn't automatically open, visit this link to log in: ${authorizeUrl}`);
+                void (0, better_opn_1.default)(authorizeUrl);
+            });
+            server.on('connection', connection => {
+                connections.add(connection);
+                connection.on('close', () => {
+                    connections.delete(connection);
+                });
+            });
+        });
+    };
+    return await executeAuthFlow();
+}

package/build/user/expoSsoLauncher.d.ts

@@ -0,0 +1,3 @@
+export declare function getSessionUsingBrowserAuthFlowAsync({ expoWebsiteUrl, }: {
+    expoWebsiteUrl: string;
+}): Promise<string>;

package/build/user/expoSsoLauncher.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionUsingBrowserAuthFlowAsync = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const better_opn_1 = tslib_1.__importDefault(require("better-opn"));
+const http_1 = tslib_1.__importDefault(require("http"));
+const querystring_1 = tslib_1.__importDefault(require("querystring"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const successBody = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Expo SSO Login</title>
+  <meta charset="utf-8">
+  <style type="text/css">
+    html {
+      margin: 0;
+      padding: 0
+    }
+
+    body {
+      background-color: #fff;
+      font-family: Tahoma,Verdana;
+      font-size: 16px;
+      color: #000;
+      max-width: 100%;
+      box-sizing: border-box;
+      padding: .5rem;
+      margin: 1em;
+      overflow-wrap: break-word
+    }
+  </style>
+</head>
+<body>
+  SSO login complete. You may now close this tab and return to the command prompt.
+</body>
+</html>`;
+async function getSessionUsingBrowserAuthFlowAsync({ expoWebsiteUrl, }) {
+    const scheme = 'http';
+    const hostname = 'localhost';
+    const path = '/auth/callback';
+    const buildExpoSsoLoginUrl = (port) => {
+        const data = {
+            app_redirect_uri: `${scheme}://${hostname}:${port}${path}`,
+        };
+        const params = querystring_1.default.stringify(data);
+        return `${expoWebsiteUrl}/sso-login?${params}`;
+    };
+    // Start server and begin auth flow
+    const executeAuthFlow = () => {
+        return new Promise(async (resolve, reject) => {
+            const connections = new Set();
+            const server = http_1.default.createServer((request, response) => {
+                try {
+                    if (!(request.method === 'GET' && request.url?.includes('/auth/callback'))) {
+                        throw new Error('Unexpected SSO login response.');
+                    }
+                    const url = new URL(request.url, `http:${request.headers.host}`);
+                    const sessionSecret = url.searchParams.get('session_secret');
+                    if (!sessionSecret) {
+                        throw new Error('Request missing session_secret search parameter.');
+                    }
+                    resolve(sessionSecret);
+                    response.writeHead(200, { 'Content-Type': 'text/html' });
+                    response.write(successBody);
+                    response.end();
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    server.close();
+                    // Ensure that the server shuts down
+                    for (const connection of connections) {
+                        connection.destroy();
+                    }
+                }
+            });
+            server.listen(0, hostname, () => {
+                log_1.default.log('Waiting for browser login...');
+                const address = server.address();
+                (0, assert_1.default)(address !== null && typeof address === 'object', 'Server address and port should be set after listening has begun');
+                const port = address.port;
+                const authorizeUrl = buildExpoSsoLoginUrl(port);
+                void (0, better_opn_1.default)(authorizeUrl);
+            });
+            server.on('connection', connection => {
+                connections.add(connection);
+                connection.on('close', () => {
+                    connections.delete(connection);
+                });
+            });
+        });
+    };
+    return await executeAuthFlow();
+}
+exports.getSessionUsingBrowserAuthFlowAsync = getSessionUsingBrowserAuthFlowAsync;

package/build/user/fetchSessionSecretAndSsoUser.d.ts

@@ -0,0 +1,5 @@
+export declare function fetchSessionSecretAndSsoUserAsync(): Promise<{
+    sessionSecret: string;
+    id: string;
+    username: string;
+}>;

package/build/user/fetchSessionSecretAndSsoUser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSessionSecretAndSsoUserAsync = void 0;
+const expoSsoLauncher_1 = require("./expoSsoLauncher");
+const fetchUser_1 = require("./fetchUser");
+const api_1 = require("../api");
+async function fetchSessionSecretAndSsoUserAsync() {
+    const sessionSecret = await (0, expoSsoLauncher_1.getSessionUsingBrowserAuthFlowAsync)({
+        expoWebsiteUrl: (0, api_1.getExpoWebsiteBaseUrl)(),
+    });
+    const userData = await (0, fetchUser_1.fetchUserAsync)({ sessionSecret });
+    return {
+        sessionSecret,
+        id: userData.id,
+        username: userData.username,
+    };
+}
+exports.fetchSessionSecretAndSsoUserAsync = fetchSessionSecretAndSsoUserAsync;

package/build/user/fetchSessionSecretAndUser.d.ts

@@ -0,0 +1,9 @@
+export declare function fetchSessionSecretAndUserAsync({ username, password, otp, }: {
+    username: string;
+    password: string;
+    otp?: string;
+}): Promise<{
+    sessionSecret: string;
+    id: string;
+    username: string;
+}>;

package/build/user/fetchSessionSecretAndUser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSessionSecretAndUserAsync = fetchSessionSecretAndUserAsync;
+const fetchUser_1 = require("./fetchUser");
+const api_1 = require("../api");
+async function fetchSessionSecretAndUserAsync({ username, password, otp, }) {
+    // this is a logged-out endpoint
+    const apiV2Client = new api_1.ApiV2Client({
+        accessToken: null,
+        sessionSecret: null,
+    });
+    const body = await apiV2Client.postAsync('auth/loginAsync', {
+        body: { username, password, otp },
+    });
+    const { sessionSecret } = body.data;
+    const userData = await (0, fetchUser_1.fetchUserAsync)({ sessionSecret });
+    return {
+        sessionSecret,
+        id: userData.id,
+        username: userData.username,
+    };
+}

package/build/user/fetchSessionSecretAndUserFromBrowserAuthFlow.d.ts

@@ -0,0 +1,7 @@
+export declare function fetchSessionSecretAndUserFromBrowserAuthFlowAsync({ sso }: {
+    sso?: boolean | undefined;
+}): Promise<{
+    sessionSecret: string;
+    id: string;
+    username: string;
+}>;

package/build/user/fetchSessionSecretAndUserFromBrowserAuthFlow.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSessionSecretAndUserFromBrowserAuthFlowAsync = fetchSessionSecretAndUserFromBrowserAuthFlowAsync;
+const expoBrowserAuthFlowLauncher_1 = require("./expoBrowserAuthFlowLauncher");
+const fetchUser_1 = require("./fetchUser");
+async function fetchSessionSecretAndUserFromBrowserAuthFlowAsync({ sso = false }) {
+    const sessionSecret = await (0, expoBrowserAuthFlowLauncher_1.getSessionUsingBrowserAuthFlowAsync)({ sso });
+    const userData = await (0, fetchUser_1.fetchUserAsync)({ sessionSecret });
+    return {
+        sessionSecret,
+        id: userData.id,
+        username: userData.username,
+    };
+}

package/build/user/fetchUser.d.ts

@@ -0,0 +1,6 @@
+export declare function fetchUserAsync({ sessionSecret, }: {
+    sessionSecret: string;
+}): Promise<{
+    id: string;
+    username: string;
+}>;

package/build/user/fetchUser.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUserAsync = fetchUserAsync;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const createGraphqlClient_1 = require("../commandUtils/context/contextUtils/createGraphqlClient");
+const client_1 = require("../graphql/client");
+async function fetchUserAsync({ sessionSecret, }) {
+    const graphqlClient = (0, createGraphqlClient_1.createGraphqlClient)({ accessToken: null, sessionSecret });
+    const result = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .query((0, graphql_tag_1.default) `
+          query MeUserActorQuery {
+            meUserActor {
+              id
+              username
+            }
+          }
+        `, {}, { additionalTypenames: ['UserActor'] })
+        .toPromise());
+    const meUserActor = result.meUserActor;
+    if (!meUserActor) {
+        throw new Error('Failed to fetch user data after login.');
+    }
+    return {
+        id: meUserActor.id,
+        username: meUserActor.username,
+    };
+}

package/build/utils/buildDistribution.d.ts

@@ -0,0 +1,3 @@
+import { BuildDistributionType } from '../build/types';
+import { DistributionType } from '../graphql/generated';
+export declare const buildDistributionTypeToGraphQLDistributionType: (buildDistribution?: BuildDistributionType) => DistributionType | undefined;