@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/account/usage.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const usageUtils_1 = require("../../commandUtils/usageUtils");
+const generated_1 = require("../../graphql/generated");
+const AccountQuery_1 = require("../../graphql/queries/AccountQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const prompts_1 = require("../../prompts");
+const json_1 = require("../../utils/json");
+const checkForOverages_1 = require("../../utils/usage/checkForOverages");
+const MiB = 1024 * 1024;
+const GiB = 1024 * MiB;
+const TiB = 1024 * GiB;
+function formatBytes(bytes) {
+    if (bytes >= TiB) {
+        return { value: bytes / TiB, unit: 'TiB' };
+    }
+    else if (bytes >= GiB) {
+        return { value: bytes / GiB, unit: 'GiB' };
+    }
+    else {
+        return { value: bytes / MiB, unit: 'MiB' };
+    }
+}
+function formatBytesDisplay(bytes) {
+    const { value, unit } = formatBytes(bytes);
+    return `${(0, usageUtils_1.formatNumber)(value, value < 10 ? 2 : value < 100 ? 1 : 0)} ${unit}`;
+}
+function displayBandwidthMetric(metric, indent = '  ') {
+    const progressBar = (0, checkForOverages_1.createProgressBar)(metric.percentUsed, 20);
+    const percentStr = `${metric.percentUsed}%`;
+    const planUsageStr = `${formatBytesDisplay(metric.planValue)}/${formatBytesDisplay(metric.limit)}`;
+    let color = chalk_1.default.green;
+    if (metric.percentUsed >= 100) {
+        color = chalk_1.default.red;
+    }
+    else if (metric.percentUsed >= 85) {
+        color = chalk_1.default.yellow;
+    }
+    log_1.default.log(`${indent}${metric.name} (plan): ${color(planUsageStr)}`);
+    log_1.default.log(`${indent}${progressBar} ${color(percentStr)}`);
+    if (metric.overageValue > 0) {
+        log_1.default.log(`${indent}${metric.name} (overage): ${chalk_1.default.red(formatBytesDisplay(metric.overageValue))} (${(0, usageUtils_1.formatCurrency)(metric.overageCost)})`);
+    }
+}
+function displayMetric(metric, indent = '  ') {
+    const progressBar = (0, checkForOverages_1.createProgressBar)(metric.percentUsed, 20);
+    const percentStr = `${metric.percentUsed}%`;
+    const planUsageStr = `${(0, usageUtils_1.formatNumber)(metric.planValue)}/${(0, usageUtils_1.formatNumber)(metric.limit)} ${metric.unit ?? ''}`;
+    let color = chalk_1.default.green;
+    if (metric.percentUsed >= 100) {
+        color = chalk_1.default.red;
+    }
+    else if (metric.percentUsed >= 85) {
+        color = chalk_1.default.yellow;
+    }
+    log_1.default.log(`${indent}${metric.name} (plan): ${color(planUsageStr)}`);
+    log_1.default.log(`${indent}${progressBar} ${color(percentStr)}`);
+    if (metric.overageValue > 0) {
+        log_1.default.log(`${indent}${metric.name} (overage): ${chalk_1.default.red(`${(0, usageUtils_1.formatNumber)(metric.overageValue)} ${metric.unit ?? ''}`)} (${(0, usageUtils_1.formatCurrency)(metric.overageCost)})`);
+    }
+}
+function billingUrl(accountName) {
+    return `https://expo.dev/accounts/${accountName}/settings/billing`;
+}
+function displayUsage(data, usageData) {
+    const subscription = usageData.subscription;
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold(`Account: ${data.accountName}`));
+    log_1.default.log(`Plan: ${data.subscriptionPlan}`);
+    if (subscription?.concurrencies) {
+        log_1.default.log(`Concurrencies: ${subscription.concurrencies.total} total (iOS: ${subscription.concurrencies.ios}, Android: ${subscription.concurrencies.android})`);
+    }
+    log_1.default.log(`Billing Period: ${(0, usageUtils_1.formatDate)(data.billingPeriod.start)} - ${(0, usageUtils_1.formatDate)(data.billingPeriod.end)}`);
+    const periodInfo = (0, usageUtils_1.calculateBillingPeriodInfo)(data);
+    log_1.default.log(`Days: ${periodInfo.daysElapsed} elapsed / ${periodInfo.totalDays} total (${periodInfo.daysRemaining} remaining)`);
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold.underline('EAS Build'));
+    displayMetric(data.builds.total);
+    if (data.builds.ios) {
+        displayMetric(data.builds.ios, '    ');
+    }
+    if (data.builds.android) {
+        displayMetric(data.builds.android, '    ');
+    }
+    // Show build counts by platform and worker size
+    if (data.builds.countsByPlatformAndSize.length > 0) {
+        log_1.default.log('  Breakdown by platform/worker:');
+        for (const item of data.builds.countsByPlatformAndSize) {
+            const platformName = item.platform === 'ios' ? 'iOS' : 'Android';
+            log_1.default.log(`    ${platformName} ${item.resourceClass}: ${(0, usageUtils_1.formatNumber)(item.count)} builds`);
+        }
+    }
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold.underline('EAS Update'));
+    displayMetric(data.updates.mau);
+    displayBandwidthMetric(data.updates.bandwidth);
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold.underline('Billing'));
+    const upcomingInvoice = subscription?.upcomingInvoice;
+    // Show subscription addons
+    if (subscription?.addons && subscription.addons.length > 0) {
+        log_1.default.log('  Addons:');
+        for (const addon of subscription.addons) {
+            log_1.default.log(`    ${addon.name}: ${addon.quantity}`);
+        }
+    }
+    // Show upcoming invoice line items
+    if (upcomingInvoice?.lineItems && upcomingInvoice.lineItems.length > 0) {
+        log_1.default.newLine();
+        log_1.default.log('  Upcoming invoice:');
+        for (const lineItem of upcomingInvoice.lineItems) {
+            const amount = lineItem.amount;
+            const amountStr = amount < 0 ? chalk_1.default.green((0, usageUtils_1.formatCurrency)(amount)) : (0, usageUtils_1.formatCurrency)(amount);
+            log_1.default.log(`    ${lineItem.description}: ${amountStr}`);
+        }
+        log_1.default.newLine();
+        log_1.default.log(`  Invoice total: ${chalk_1.default.bold((0, usageUtils_1.formatCurrency)(upcomingInvoice.total))}`);
+    }
+    else {
+        // Fallback to the calculated estimate if no upcoming invoice
+        if (data.recurringCents !== null && data.recurringCents > 0) {
+            log_1.default.log(`  Base subscription: ${(0, usageUtils_1.formatCurrency)(data.recurringCents)}`);
+        }
+        if (data.totalOverageCostCents > 0) {
+            log_1.default.log(`  Current overages: ${chalk_1.default.yellow((0, usageUtils_1.formatCurrency)(data.totalOverageCostCents))}`);
+            if (data.builds.overageCostCents > 0) {
+                log_1.default.log(`    Build overages: ${(0, usageUtils_1.formatCurrency)(data.builds.overageCostCents)}`);
+                // Show breakdown by worker size
+                for (const overage of data.builds.overagesByWorkerSize) {
+                    const platformName = overage.platform === generated_1.AppPlatform.Ios ? 'iOS' : 'Android';
+                    const sizeName = overage.resourceClass === generated_1.EasBuildBillingResourceClass.Large ? 'large' : 'medium';
+                    log_1.default.log(`      ${platformName} ${sizeName}: ${(0, usageUtils_1.formatNumber)(overage.count)} builds (${(0, usageUtils_1.formatCurrency)(overage.costCents)})`);
+                }
+            }
+            if (data.updates.overageCostCents > 0) {
+                log_1.default.log(`    Update overages: ${(0, usageUtils_1.formatCurrency)(data.updates.overageCostCents)}`);
+            }
+        }
+        log_1.default.log(`  Estimated bill: ${chalk_1.default.bold((0, usageUtils_1.formatCurrency)(data.estimatedBillCents))}`);
+    }
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.dim(`View detailed billing: ${(0, log_1.link)(billingUrl(data.accountName))}`));
+}
+class AccountUsage extends EasCommand_1.default {
+    static description = 'view account usage and billing for the current cycle';
+    static args = {
+        ACCOUNT_NAME: core_1.Args.string({
+            description: 'Account name to view usage for. If not provided, the account will be selected interactively (or defaults to the only account if there is just one)',
+        }),
+    };
+    static flags = {
+        ...flags_1.EasJsonOnlyFlag,
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args: { ACCOUNT_NAME: accountName }, flags: { json: jsonFlag, 'non-interactive': nonInteractive }, } = await this.parse(AccountUsage);
+        // Enable JSON output if either --json or --non-interactive is passed
+        const json = jsonFlag || nonInteractive;
+        if (json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { loggedIn: { graphqlClient, actor }, } = await this.getContextAsync(AccountUsage, {
+            nonInteractive,
+        });
+        // Find the target account
+        const defaultAccount = actor.accounts[0];
+        let targetAccount;
+        const availableAccounts = actor.accounts.map(a => a.name).join(', ');
+        if (accountName) {
+            // First check if it's one of the user's accounts
+            const found = actor.accounts.find(a => a.name === accountName);
+            if (found) {
+                targetAccount = found;
+            }
+            else {
+                // Try to look up the account by name (user may have access via organization)
+                try {
+                    const account = await AccountQuery_1.AccountQuery.getByNameAsync(graphqlClient, accountName);
+                    if (!account) {
+                        throw new Error(`Account "${accountName}" not found. Available accounts: ${availableAccounts}`);
+                    }
+                    targetAccount = account;
+                }
+                catch {
+                    throw new Error(`Account "${accountName}" not found or you don't have access. Available accounts: ${availableAccounts}`);
+                }
+            }
+        }
+        else if (nonInteractive) {
+            throw new Error('ACCOUNT_NAME argument must be provided when running in `--non-interactive` mode.');
+        }
+        else if (actor.accounts.length === 1) {
+            // Only one account, use it directly
+            targetAccount = defaultAccount;
+        }
+        else {
+            // Prompt user to select an account
+            targetAccount = await (0, prompts_1.selectAsync)('Select account to view usage for:', actor.accounts.map(account => ({
+                title: account.name,
+                value: account,
+            })), { initial: defaultAccount });
+        }
+        const spinner = (0, ora_1.ora)(`Fetching usage data for account ${targetAccount.name}`).start();
+        try {
+            const currentDate = new Date();
+            const { start, end } = await AccountQuery_1.AccountQuery.getBillingPeriodAsync(graphqlClient, targetAccount.id, currentDate);
+            const usageData = await AccountQuery_1.AccountQuery.getFullUsageAsync(graphqlClient, targetAccount.id, currentDate, start, end);
+            log_1.default.debug(JSON.stringify(usageData, null, 2));
+            spinner.succeed(`Usage data loaded for ${targetAccount.name}`);
+            const displayData = (0, usageUtils_1.extractUsageData)(usageData);
+            const periodInfo = (0, usageUtils_1.calculateBillingPeriodInfo)(displayData);
+            if (json) {
+                const subscription = usageData.subscription;
+                (0, json_1.printJsonOnlyOutput)({
+                    account: {
+                        name: displayData.accountName,
+                        plan: displayData.subscriptionPlan,
+                        concurrencies: subscription?.concurrencies ?? null,
+                        billingPeriod: {
+                            start: displayData.billingPeriod.start,
+                            end: displayData.billingPeriod.end,
+                            daysElapsed: periodInfo.daysElapsed,
+                            daysRemaining: periodInfo.daysRemaining,
+                            totalDays: periodInfo.totalDays,
+                        },
+                    },
+                    builds: {
+                        plan: {
+                            used: displayData.builds.total.planValue,
+                            limit: displayData.builds.total.limit,
+                            percentUsed: displayData.builds.total.percentUsed,
+                        },
+                        overage: {
+                            count: displayData.builds.total.overageValue,
+                            costCents: displayData.builds.total.overageCost,
+                            byWorkerSize: displayData.builds.overagesByWorkerSize.map(o => ({
+                                platform: o.platform.toLowerCase(),
+                                resourceClass: o.resourceClass.toLowerCase(),
+                                count: o.count,
+                                costCents: o.costCents,
+                            })),
+                        },
+                        byPlatformAndSize: displayData.builds.countsByPlatformAndSize.map(item => ({
+                            platform: item.platform,
+                            resourceClass: item.resourceClass,
+                            count: item.count,
+                        })),
+                        ios: displayData.builds.ios
+                            ? {
+                                plan: {
+                                    used: displayData.builds.ios.planValue,
+                                    limit: displayData.builds.ios.limit,
+                                    percentUsed: displayData.builds.ios.percentUsed,
+                                },
+                            }
+                            : null,
+                        android: displayData.builds.android
+                            ? {
+                                plan: {
+                                    used: displayData.builds.android.planValue,
+                                    limit: displayData.builds.android.limit,
+                                    percentUsed: displayData.builds.android.percentUsed,
+                                },
+                            }
+                            : null,
+                    },
+                    updates: {
+                        uniqueUpdaters: {
+                            plan: {
+                                used: displayData.updates.mau.planValue,
+                                limit: displayData.updates.mau.limit,
+                                percentUsed: displayData.updates.mau.percentUsed,
+                            },
+                            overage: {
+                                count: displayData.updates.mau.overageValue,
+                                costCents: displayData.updates.mau.overageCost,
+                            },
+                        },
+                        bandwidth: {
+                            plan: {
+                                usedBytes: displayData.updates.bandwidth.planValue,
+                                usedFormatted: formatBytesDisplay(displayData.updates.bandwidth.planValue),
+                                limitBytes: displayData.updates.bandwidth.limit,
+                                limitFormatted: formatBytesDisplay(displayData.updates.bandwidth.limit),
+                                percentUsed: displayData.updates.bandwidth.percentUsed,
+                            },
+                            overage: {
+                                usedBytes: displayData.updates.bandwidth.overageValue,
+                                usedFormatted: formatBytesDisplay(displayData.updates.bandwidth.overageValue),
+                                costCents: displayData.updates.bandwidth.overageCost,
+                            },
+                        },
+                        overageCostCents: displayData.updates.overageCostCents,
+                    },
+                    billing: {
+                        addons: subscription?.addons ?? [],
+                        upcomingInvoice: subscription?.upcomingInvoice ?? null,
+                        estimated: {
+                            recurringCents: displayData.recurringCents,
+                            overageCents: displayData.totalOverageCostCents,
+                            totalCents: displayData.estimatedBillCents,
+                        },
+                    },
+                    billingUrl: billingUrl(displayData.accountName),
+                });
+            }
+            else {
+                displayUsage(displayData, usageData);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch usage data');
+            throw error;
+        }
+    }
+}
+exports.default = AccountUsage;

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

@@ -0,0 +1,11 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class AccountView extends EasCommand {
+    static description: string;
+    static aliases: string[];
+    static contextDefinition: {
+        maybeLoggedIn: import("../../commandUtils/context/MaybeLoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+    private static getRoleOnAccount;
+    private static getLabelForRole;
+}

package/build/commands/account/view.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const generated_1 = require("../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const User_1 = require("../../user/User");
+class AccountView extends EasCommand_1.default {
+    static description = 'show the username you are logged in as';
+    static aliases = ['whoami'];
+    static contextDefinition = {
+        ...this.ContextOptions.MaybeLoggedIn,
+    };
+    async runAsync() {
+        const { maybeLoggedIn: { actor, authenticationInfo }, } = await this.getContextAsync(AccountView, { nonInteractive: true });
+        if (actor) {
+            const displayName = (0, User_1.getActorDisplayName)(actor);
+            const loggedInAs = authenticationInfo.accessToken
+                ? `${displayName} (authenticated using EXPO_TOKEN)`
+                : displayName;
+            log_1.default.log(chalk_1.default.green(loggedInAs));
+            if ('email' in actor) {
+                log_1.default.log(actor.email);
+            }
+            // personal account is included, only show if more accounts that personal account
+            // but do show personal account in list if there are more
+            const accountExcludingPersonalAccount = actor.accounts.filter(account => !('username' in actor) || account.name !== actor.username);
+            if (accountExcludingPersonalAccount.length > 0) {
+                log_1.default.newLine();
+                log_1.default.log('Accounts:');
+                actor.accounts.forEach(account => {
+                    const roleOnAccount = AccountView.getRoleOnAccount(actor, account);
+                    log_1.default.log(`• ${account.name} (Role: ${AccountView.getLabelForRole(roleOnAccount)})`);
+                });
+            }
+        }
+        else {
+            log_1.default.warn('Not logged in');
+            process.exit(1);
+        }
+    }
+    static getRoleOnAccount(actor, account) {
+        if ('username' in actor && account.name === actor.username) {
+            return generated_1.Role.Owner;
+        }
+        return (0, nullthrows_1.default)(account.users.find(user => user.actor.id === actor.id)?.role);
+    }
+    static getLabelForRole(role) {
+        switch (role) {
+            case generated_1.Role.Owner:
+                return 'Owner';
+            case generated_1.Role.Admin:
+                return 'Admin';
+            case generated_1.Role.Developer:
+                return 'Developer';
+            case generated_1.Role.ViewOnly:
+                return 'Viewer';
+            case generated_1.Role.Custom:
+            case generated_1.Role.HasAdmin:
+            case generated_1.Role.NotAdmin:
+                return 'Custom';
+        }
+    }
+}
+exports.default = AccountView;

package/build/commands/analytics.d.ts

@@ -0,0 +1,8 @@
+import EasCommand from '../commandUtils/EasCommand';
+export default class AnalyticsView extends EasCommand {
+    static description: string;
+    static args: {
+        STATUS: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/analytics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const EasCommand_1 = tslib_1.__importDefault(require("../commandUtils/EasCommand"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+class AnalyticsView extends EasCommand_1.default {
+    static description = 'display or change analytics settings';
+    static args = {
+        STATUS: core_1.Args.string({
+            options: ['on', 'off'],
+        }),
+    };
+    async runAsync() {
+        const { STATUS: status } = (await this.parse(AnalyticsView)).args;
+        if (status) {
+            await (0, AnalyticsManager_1.setAnalyticsEnabledAsync)(status === 'on');
+            log_1.default.withTick(`${status === 'on' ? 'Enabling' : 'Disabling'} analytics.`);
+        }
+        else {
+            const analyticsEnabled = await (0, AnalyticsManager_1.getAnalyticsEnabledAsync)();
+            log_1.default.log(`Analytics are ${analyticsEnabled === false ? 'disabled' : 'enabled'} on this eas-cli installation.`);
+        }
+    }
+}
+exports.default = AnalyticsView;

package/build/commands/branch/create.d.ts

@@ -0,0 +1,17 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class BranchCreate extends EasCommand {
+    static description: string;
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/branch/create.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const queries_1 = require("../../branch/queries");
+const utils_1 = require("../../branch/utils");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const json_1 = require("../../utils/json");
+class BranchCreate extends EasCommand_1.default {
+    static description = 'create a branch';
+    static args = {
+        name: core_1.Args.string({
+            required: false,
+            description: 'Name of the branch to create',
+        }),
+    };
+    static flags = {
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.Vcs,
+    };
+    async runAsync() {
+        let { args: { name }, flags, } = await this.parse(BranchCreate);
+        const { json: jsonFlag, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const { projectId, loggedIn: { graphqlClient }, vcsClient, } = await this.getContextAsync(BranchCreate, {
+            nonInteractive,
+        });
+        if (jsonFlag) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
+        if (!name) {
+            const validationMessage = 'Branch name may not be empty.';
+            if (nonInteractive) {
+                throw new Error(validationMessage);
+            }
+            ({ name } = await (0, prompts_1.promptAsync)({
+                type: 'text',
+                name: 'name',
+                message: 'Provide a branch name:',
+                initial: (await (0, utils_1.getDefaultBranchNameAsync)(vcsClient)) ?? undefined,
+                validate: value => (value ? true : validationMessage),
+            }));
+            if (!name) {
+                throw new Error(validationMessage);
+            }
+        }
+        const newBranch = await (0, queries_1.createUpdateBranchOnAppAsync)(graphqlClient, { appId: projectId, name });
+        if (jsonFlag) {
+            (0, json_1.printJsonOnlyOutput)(newBranch);
+        }
+        else {
+            log_1.default.withTick(`️Created a new branch: ${chalk_1.default.bold(newBranch.name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
+        }
+    }
+}
+exports.default = BranchCreate;

package/build/commands/branch/delete.d.ts

@@ -0,0 +1,16 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class BranchDelete extends EasCommand {
+    static description: string;
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectId: import("../../commandUtils/context/ProjectIdContextField").ProjectIdContextField;
+    };
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/branch/delete.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const delete_1 = require("../../branch/delete");
+const queries_1 = require("../../branch/queries");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const pagination_1 = require("../../commandUtils/pagination");
+const client_1 = require("../../graphql/client");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const json_1 = require("../../utils/json");
+const pollForBackgroundJobReceiptAsync_1 = require("../../utils/pollForBackgroundJobReceiptAsync");
+async function getBranchInfoAsync(graphqlClient, { appId, name }) {
+    const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+        .query((0, graphql_tag_1.default) `
+          query GetBranchInfo($appId: String!, $name: String!) {
+            app {
+              byId(appId: $appId) {
+                id
+                updateBranchByName(name: $name) {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        `, {
+        appId,
+        name,
+    }, { additionalTypenames: ['UpdateBranch'] })
+        .toPromise());
+    return data;
+}
+class BranchDelete extends EasCommand_1.default {
+    static description = 'delete a branch';
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    static args = {
+        name: core_1.Args.string({
+            required: false,
+            description: 'Name of the branch to delete',
+        }),
+    };
+    static flags = {
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    async runAsync() {
+        let { args: { name: branchName }, flags, } = await this.parse(BranchDelete);
+        const { json: jsonFlag, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const paginatedQueryOptions = (0, pagination_1.getPaginatedQueryOptions)(flags);
+        if (jsonFlag) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(BranchDelete, { nonInteractive });
+        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
+        if (!branchName) {
+            const validationMessage = 'branch name may not be empty.';
+            if (nonInteractive) {
+                throw new Error(validationMessage);
+            }
+            ({ name: branchName } = await (0, queries_1.selectBranchOnAppAsync)(graphqlClient, {
+                projectId,
+                displayTextForListItem: updateBranch => ({ title: updateBranch.name }),
+                promptTitle: 'Which branch would you like to delete?',
+                paginatedQueryOptions,
+            }));
+        }
+        const data = await getBranchInfoAsync(graphqlClient, { appId: projectId, name: branchName });
+        const branchId = data.app?.byId.updateBranchByName?.id;
+        if (!branchId) {
+            throw new Error(`Could not find branch ${branchName} on ${projectDisplayName}`);
+        }
+        if (!nonInteractive) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.warn(`You are about to permanently delete branch: "${branchName}" and all of the updates published on it.` +
+                `\nThis action is irreversible.`);
+            log_1.default.newLine();
+            const confirmed = await (0, prompts_1.toggleConfirmAsync)({ message: 'Are you sure you wish to proceed?' });
+            if (!confirmed) {
+                log_1.default.error(`Cancelled deletion of branch: "${branchName}".`);
+                process.exit(1);
+            }
+        }
+        const receipt = await (0, delete_1.scheduleBranchDeletionAsync)(graphqlClient, { branchId });
+        const successfulReceipt = await (0, pollForBackgroundJobReceiptAsync_1.pollForBackgroundJobReceiptAsync)(graphqlClient, receipt);
+        log_1.default.debug('Deletion result', { successfulReceipt });
+        if (jsonFlag) {
+            (0, json_1.printJsonOnlyOutput)({ id: branchId });
+        }
+        else {
+            log_1.default.withTick(`️Deleted branch "${branchName}" and all of its updates on project ${chalk_1.default.bold(projectDisplayName)}.`);
+        }
+    }
+}
+exports.default = BranchDelete;

package/build/commands/branch/list.d.ts

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