eas-cli 20.2.0 → 20.4.0

package/build/observe/formatSessions.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObserveSessionEventsTable = buildObserveSessionEventsTable;
+exports.buildObserveSessionEventsJson = buildObserveSessionEventsJson;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const formatUtils_1 = require("./formatUtils");
+const metricNames_1 = require("./metricNames");
+const renderTextTable_1 = tslib_1.__importDefault(require("../utils/renderTextTable"));
+function formatEntryName(entry) {
+    if (entry.source === 'metric' && entry.metricName) {
+        const name = (0, metricNames_1.getMetricDisplayName)(entry.metricName);
+        return entry.routeName ? `${name} · ${entry.routeName}` : name;
+    }
+    return entry.eventName ?? '-';
+}
+function formatMetricEntryValue(entry) {
+    if (typeof entry.metricValue === 'number') {
+        return `${entry.metricValue.toFixed(2)}s`;
+    }
+    return '-';
+}
+function formatEntrySeverity(entry) {
+    if (entry.source !== 'log') {
+        return '-';
+    }
+    if (entry.severityText) {
+        return entry.severityText;
+    }
+    if (entry.severityNumber != null) {
+        return String(entry.severityNumber);
+    }
+    return '-';
+}
+function primitivePropertyLines(entry) {
+    if (entry.source !== 'log' || !entry.properties) {
+        return [];
+    }
+    return entry.properties
+        .filter(p => p.type === 'STRING' || p.type === 'NUMBER' || p.type === 'BOOLEAN')
+        .map(p => `${p.key}=${p.value}`);
+}
+function formatOffsetSeconds(startIso, currentIso) {
+    const offsetMs = new Date(currentIso).getTime() - new Date(startIso).getTime();
+    return `${(offsetMs / 1000).toFixed(2)}s`;
+}
+function buildObserveSessionEventsTable(entries, options) {
+    const lines = [];
+    if (options?.metadata) {
+        const { metadata } = options;
+        lines.push(`App version: ${metadata.appVersion} (${metadata.appBuildNumber})`, `Device:      ${metadata.deviceModel} · ${metadata.deviceOs} ${metadata.deviceOsVersion}`, `First seen:  ${(0, formatUtils_1.formatLogTimestamp)(metadata.firstSeenAt)}`, `Last seen:   ${(0, formatUtils_1.formatLogTimestamp)(metadata.lastSeenAt)}`, '');
+    }
+    if (entries.length === 0) {
+        lines.push(chalk_1.default.yellow('No events found for this session.'));
+        return lines.join('\n');
+    }
+    const startIso = entries[0].timestamp;
+    const headers = ['Offset', 'Type', 'Name', 'Value', 'Properties', 'Severity'];
+    const rows = [];
+    for (const entry of entries) {
+        const offset = formatOffsetSeconds(startIso, entry.timestamp);
+        const type = entry.source === 'metric' ? 'metric' : 'log';
+        const name = formatEntryName(entry);
+        const severity = formatEntrySeverity(entry);
+        if (entry.source === 'metric') {
+            rows.push([offset, type, name, formatMetricEntryValue(entry), '-', severity]);
+            continue;
+        }
+        const propLines = primitivePropertyLines(entry);
+        if (propLines.length === 0) {
+            rows.push([offset, type, name, '-', '-', severity]);
+            continue;
+        }
+        rows.push([offset, type, name, '-', propLines[0], severity]);
+        for (let i = 1; i < propLines.length; i++) {
+            rows.push(['', '', '', '', propLines[i], '']);
+        }
+    }
+    lines.push((0, renderTextTable_1.default)(headers, rows));
+    if (options?.hasMoreMetricEvents || options?.hasMoreLogEvents) {
+        const sources = [];
+        if (options.hasMoreMetricEvents) {
+            sources.push('metric events');
+        }
+        if (options.hasMoreLogEvents) {
+            sources.push('log events');
+        }
+        lines.push('', chalk_1.default.yellow(`More ${sources.join(' and ')} are available for this session; only the first 100 of each are shown.`));
+    }
+    return lines.join('\n');
+}
+function buildObserveSessionEventsJson(entries, sessionId, metadata, hasMoreMetricEvents, hasMoreLogEvents) {
+    return {
+        sessionId,
+        metadata,
+        entries,
+        hasMoreMetricEvents,
+        hasMoreLogEvents,
+    };
+}

package/build/simulator/utils.js

@@ -24,6 +24,10 @@ function getRemoteSessionEnvironmentVariables(remoteConfig) {
                 AGENT_DEVICE_DAEMON_AUTH_TOKEN: remoteConfig.agentDeviceRemoteSessionToken,
             };
         case 'ArgentRunSessionRemoteConfig':
+            return {
+                ARGENT_TOOLS_URL: remoteConfig.toolsUrl,
+                ...(remoteConfig.toolsAuthToken ? { ARGENT_AUTH_TOKEN: remoteConfig.toolsAuthToken } : {}),
+            };
         case 'ServeSimRunSessionRemoteConfig':
             return {};
     }
@@ -49,11 +53,30 @@ function formatRemoteSessionInstructions(remoteConfig, configType) {
             return lines.join('\n');
         }
         case 'ArgentRunSessionRemoteConfig': {
-            const lines = [
-                '🔑 Open the following URL to access the Argent tools for this session:',
-                '',
-                remoteConfig.toolsUrl,
-            ];
+            const environmentVariables = getRemoteSessionEnvironmentVariables(remoteConfig);
+            const lines = configType === 'dotenv'
+                ? [
+                    '🔑 Run the following to link your local Argent client to this simulator session:',
+                    '',
+                    [
+                        'argent',
+                        'link',
+                        `'${remoteConfig.toolsUrl}'`,
+                        remoteConfig.toolsAuthToken
+                            ? `--token '${remoteConfig.toolsAuthToken}'`
+                            : undefined,
+                        '--yes',
+                    ]
+                        .filter(Boolean)
+                        .join(' '),
+                    '',
+                    'Restart your editor after linking so its Argent MCP process uses the remote session.',
+                ]
+                : [
+                    '🔑 Run the following in your shell to attach Argent to this simulator session:',
+                    '',
+                    ...Object.entries(environmentVariables).map(([key, value]) => `export ${key}='${value}'`),
+                ];
             if (remoteConfig.webPreviewUrl) {
                 lines.push('', '🌐 Open the following URL in your browser to preview the simulator:', '', remoteConfig.webPreviewUrl);
             }

package/build/update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.js

@@ -6,40 +6,37 @@ const errors_1 = require("../channel/errors");
 const queries_2 = require("../channel/queries");
 const ChannelQuery_1 = require("../graphql/queries/ChannelQuery");
 async function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient, projectId, channelName) {
-    let branchInfo;
+    let channel;
     try {
-        const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+        channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
             appId: projectId,
             channelName,
         });
-        if (channel.updateBranches.length === 1) {
-            const branch = channel.updateBranches[0];
-            branchInfo = { branchId: branch.id, branchName: branch.name };
-        }
-        else if (channel.updateBranches.length === 0) {
-            throw new Error("Channel has no branches associated with it. Run 'eas channel:edit' to map a branch");
-        }
-        else {
-            throw new Error(`Channel has multiple branches associated with it. Instead, use '--branch' instead of '--channel'`);
-        }
     }
     catch (error) {
         if (!(error instanceof errors_1.ChannelNotFoundError)) {
             throw error;
         }
-        const { branch } = await (0, queries_1.ensureBranchExistsAsync)(graphqlClient, {
-            appId: projectId,
-            branchName: channelName,
-        });
-        const { updateChannel: { createUpdateChannelForApp: newChannel }, } = await (0, queries_2.createChannelOnAppAsync)(graphqlClient, {
-            appId: projectId,
-            channelName,
-            branchId: branch.id,
-        });
-        if (!newChannel) {
-            throw new Error(`Could not create channel with name ${channelName} on project with id ${projectId}`);
-        }
-        branchInfo = { branchId: branch.id, branchName: channelName };
+        return await createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName);
     }
-    return branchInfo;
+    if (channel.updateBranches.length === 1) {
+        const branch = channel.updateBranches[0];
+        return { branchId: branch.id, branchName: branch.name };
+    }
+    if (channel.updateBranches.length === 0) {
+        return await createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName);
+    }
+    throw new Error(`Channel has multiple branches associated with it. Instead, use '--branch' instead of '--channel'`);
+}
+async function createAndLinkBranchToChannelAsync(graphqlClient, projectId, channelName) {
+    const { branch } = await (0, queries_1.ensureBranchExistsAsync)(graphqlClient, {
+        appId: projectId,
+        branchName: channelName,
+    });
+    await (0, queries_2.createChannelOnAppAsync)(graphqlClient, {
+        appId: projectId,
+        channelName,
+        branchId: branch.id,
+    });
+    return { branchId: branch.id, branchName: channelName };
 }

package/build/user/SessionManager.d.ts

@@ -1,9 +1,5 @@
 import { AnalyticsWithOrchestration } from '../analytics/AnalyticsManager';
 import { CurrentUserQuery } from '../graphql/generated';
-export declare enum UserSecondFactorDeviceMethod {
-    AUTHENTICATOR = "authenticator",
-    SMS = "sms"
-}
 export type LoggedInAuthenticationInfo = {
     accessToken: string;
     sessionSecret: null;
@@ -52,24 +48,7 @@ export default class SessionManager {
      */
     private promptForOTPAsync;
     /**
-     * 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.
-     */
-    private promptForBackupOTPAsync;
-    /**
-     * 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.
+     * Handle the special case error indicating that a second-factor is required for authentication.
      */
     private retryUsernamePasswordAuthWithOTPAsync;
 }

package/build/user/SessionManager.js

@@ -1,10 +1,8 @@
 "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");
@@ -16,11 +14,6 @@ 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;
@@ -145,7 +138,7 @@ class SessionManager {
         }
         catch (e) {
             if (e instanceof ApiV2Error_1.ApiV2Error && e.expoApiV2ErrorCode === 'ONE_TIME_PASSWORD_REQUIRED') {
-                await this.retryUsernamePasswordAuthWithOTPAsync(username, password, e.expoApiV2ErrorMetadata);
+                await this.retryUsernamePasswordAuthWithOTPAsync(username, password);
             }
             else {
                 throw e;
@@ -173,10 +166,8 @@ class SessionManager {
     /**
      * 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`;
+    async promptForOTPAsync() {
+        const enterMessage = `press ${chalk_1.default.bold('Enter')} to cancel`;
         const { otp } = await (0, prompts_1.promptAsync)({
             type: 'text',
             name: 'otp',
@@ -188,84 +179,11 @@ class SessionManager {
         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.
+     * Handle the special case error indicating that a second-factor is required for authentication.
      */
-    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);
-        }
+    async retryUsernamePasswordAuthWithOTPAsync(username, password) {
+        log_1.default.log('One-time password from authenticator required.');
+        const otp = await this.promptForOTPAsync();
         if (!otp) {
             throw new Error('Cancelled login');
         }