hotcodepush 0.0.1 → 0.2.0

package/dist/commands/organization/get.js

@@ -0,0 +1,38 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { resolveDollarText } from '../../utils/spending-cap.js';
+export default defineCommand({
+    description: 'Print an organization with its plan, spending cap and region.',
+    examples: [
+        'hotcodepush organization get --organization Acme',
+        'hotcodepush organization get --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedOrganization = await hotCodePush.organizations.get({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(fetchedOrganization);
+            return;
+        }
+        printOrganizationDetails(fetchedOrganization);
+    },
+});
+export function printOrganizationDetails(organization) {
+    printDetails([
+        ['ID', organization.id],
+        ['Name', organization.name],
+        ['Plan', organization.plan],
+        [
+            'Spending cap',
+            `${resolveDollarText(organization.spendingCapCents)} a month`,
+        ],
+        ['Region', organization.region],
+        ['Created', organization.createdAt],
+    ]);
+}

package/dist/commands/organization/list.js

@@ -0,0 +1,41 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { resolveMemberRole } from '../../utils/member-resolution.js';
+import { printJson, printTable, resolveDate } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+export default defineCommand({
+    description: 'List your organizations with your role in each, newest first.',
+    examples: [
+        'hotcodepush organization list',
+        'hotcodepush organization list --limit 10 --offset 10 --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedOrganizations = await hotCodePush.organizations.list({
+            limit: options.limit,
+            offset: options.offset,
+        });
+        const nextOffset = resolveNextOffset(listedOrganizations.length, options);
+        if (options.json) {
+            printJson({ nextOffset, organizations: listedOrganizations });
+            return;
+        }
+        const { members = [] } = await hotCodePush.users.get({
+            relations: ['members'],
+            userId: 'me',
+        });
+        printTable({
+            emptyText: 'No organizations.',
+            headers: ['ID', 'NAME', 'ROLE', 'CREATED'],
+            nextOffset,
+            rows: listedOrganizations.map(({ createdAt, id, name }) => [
+                id,
+                name,
+                resolveMemberRole(members, id) ?? '',
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/organization/update.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence, promptText } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { resolveCents, resolveDollarText, spendingCapShape, } from '../../utils/spending-cap.js';
+import { printOrganizationDetails } from './get.js';
+export default defineCommand({
+    description: 'Rename an organization or set its spending cap, which applies now.',
+    examples: [
+        'hotcodepush organization update --organization Acme --name "Acme Inc"',
+        'hotcodepush organization update --spending-cap 100 --yes --json',
+    ],
+    options: defineCommandOptions({
+        name: z.string().optional().describe("The organization's new name."),
+        ...spendingCapShape,
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const spendingCapCents = options.spendingCap === undefined
+            ? undefined
+            : resolveCents(options.spendingCap);
+        const name = options.name ??
+            (spendingCapCents === undefined
+                ? await promptText('--name', 'What is the organization called now?', options)
+                : undefined);
+        if (spendingCapCents !== undefined) {
+            const fetchedOrganization = await hotCodePush.organizations.get({
+                organizationId,
+            });
+            const isConfirmed = await confirmSpendingCapChange(fetchedOrganization, spendingCapCents, options);
+            if (!isConfirmed) {
+                return;
+            }
+        }
+        const updatedOrganization = await hotCodePush.organizations.update({
+            name,
+            organizationId,
+            spendingCapCents,
+        });
+        if (options.json) {
+            printJson(updatedOrganization);
+        }
+        else {
+            printOrganizationDetails(updatedOrganization);
+        }
+    },
+});
+// An unchanged cap needs no confirmation, since the API answers it with `no_change`.
+async function confirmSpendingCapChange(organization, spendingCapCents, options) {
+    return (spendingCapCents === organization.spendingCapCents ||
+        confirmConsequence(resolveSpendingCapConsequence(organization, spendingCapCents), options));
+}
+function resolveSpendingCapConsequence(organization, spendingCapCents) {
+    const capText = `the spending cap of ${organization.name}`;
+    const previousText = resolveDollarText(organization.spendingCapCents);
+    const newText = resolveDollarText(spendingCapCents);
+    return spendingCapCents > organization.spendingCapCents
+        ? `raises ${capText} from ${previousText} to ${newText} a month and applies now`
+        : `lowers ${capText} from ${previousText} to ${newText} a month and applies now. Devices counted this month stay counted, and if they already exceed the new cap, no further device is counted until the cap is raised or the month turns`;
+}

package/dist/commands/release/create.js

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveAudienceText } from '../../utils/audience.js';
+import { booleanFlagSchema } from '../../utils/boolean-flag.js';
+import { fetchBundle, resolveBundleLabel, } from '../../utils/bundle-resolution.js';
+import { failurePolicyShape, resolveFailurePolicy, } from '../../utils/channel-fields.js';
+import { defineCommand } from '../../utils/command.js';
+import { withTemporaryDirectory } from '../../utils/compressed-files.js';
+import { InvalidParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printWarnings } from '../../utils/output.js';
+import { progressionShape, resolveProgression, resolveProgressionText, } from '../../utils/progression.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { buildAudienceQuery, buildReleaseConditions, conditionOptionShape, } from '../../utils/release-conditions.js';
+import { printReleasedLine } from '../../utils/release-output.js';
+import { fetchReleaseLog, waitUntilLive, } from '../../utils/release-resolution.js';
+import { fetchAppId, fetchChannelId, fetchChannels, fetchResourceId, } from '../../utils/resource-resolution.js';
+import { assertWithinBundleBytesLimit, collectUploadFiles, uploadBundle, } from '../../utils/upload.js';
+import { bundleUploadOptionShape, resolveUploadBundleOptions, } from '../bundle/upload.js';
+export default defineCommand({
+    description: 'Release a bundle to a channel, uploading the build first unless --bundle or --from-channel names one, and wait until it is live.',
+    examples: [
+        'hotcodepush release create --path dist',
+        'hotcodepush release create --from-channel staging --channel production --binary-version ">=2.3.0" --progression --dry-run',
+    ],
+    options: defineCommandOptions({
+        ...bundleUploadOptionShape,
+        ...conditionOptionShape,
+        ...failurePolicyShape,
+        ...progressionShape,
+        bundle: z
+            .string()
+            .optional()
+            .describe('A bundle already uploaded, by number or id. Without it the build is uploaded first.'),
+        channel: z
+            .array(z.string())
+            .optional()
+            .describe("The channel, by id or name, repeatable. Defaults to hotcodepush.json's channel."),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe('Validate and print the audience the release would reach. Nothing is signed, uploaded or published, so no private key is needed.'),
+        fromChannel: z
+            .string()
+            .optional()
+            .describe('Release what this channel serves, by id or name, instead of a bundle or a build.'),
+        mandatory: booleanFlagSchema
+            .optional()
+            .describe('Devices apply the release at once and restart.'),
+        notes: z
+            .string()
+            .optional()
+            .describe('The release notes. They ride the public index.'),
+        rolloutPercent: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe("The share of devices the release reaches, 0 to 100; 100 by default, the schedule's first percentage with --progression."),
+    }),
+    action: options => withTemporaryDirectory(packagingDirectoryPath => createReleases(options, packagingDirectoryPath)),
+});
+// The packaging directory is removed when the command ends.
+async function createReleases(options, packagingDirectoryPath) {
+    const hotCodePush = createApiClient();
+    const progression = resolveProgression(options);
+    const bundleSource = await resolveBundleSource(hotCodePush, options, packagingDirectoryPath);
+    const fingerprint = resolveSourceFingerprint(bundleSource);
+    const isMandatory = options.mandatory ?? false;
+    const rolloutPercent = options.rolloutPercent ?? progression?.rolloutPercents[0] ?? 100;
+    const appId = 'bundle' in bundleSource ? bundleSource.bundle.appId : bundleSource.appId;
+    const channelAudiences = await fetchChannelAudiences(hotCodePush, appId, options, fingerprint, rolloutPercent);
+    const consequence = resolveReleaseConsequence(bundleSource, channelAudiences, { isMandatory, progression, rolloutPercent });
+    if (options.dryRun) {
+        await printDryRun(bundleSource, channelAudiences, consequence, options);
+        return;
+    }
+    if (!(await confirmConsequence(consequence, options))) {
+        return;
+    }
+    const releases = [];
+    for (const bundle of await resolveReleasedBundles(hotCodePush, bundleSource)) {
+        const releaseBody = {
+            ...('sourceChannel' in bundleSource
+                ? { fromChannelId: bundleSource.sourceChannel.id }
+                : { bundleId: bundle.id }),
+            conditions: buildReleaseConditions(options, fingerprint),
+            ...resolveFailurePolicy(options),
+            isMandatory,
+            notes: options.notes ?? null,
+            progression: progression ?? undefined,
+            rolloutPercent,
+        };
+        for (const { channel } of channelAudiences) {
+            const createdRelease = await hotCodePush.apps.channels.releases.create({
+                ...releaseBody,
+                appId: bundle.appId,
+                channelId: channel.id,
+            });
+            const liveRelease = await waitUntilLive(hotCodePush, bundle.appId, createdRelease.id, ['bundle', 'channel']);
+            releases.push(liveRelease);
+            if (!options.json) {
+                printReleasedLine(liveRelease, channel.name, resolveBundleLabel(bundle));
+            }
+        }
+    }
+    printAudienceWarnings(channelAudiences);
+    if (options.json) {
+        printJson(releases);
+    }
+}
+export function resolveReleaseConsequence(bundleSource, channelAudiences, { isMandatory, progression, rolloutPercent }) {
+    const audienceText = channelAudiences
+        .map(({ audience, channel }) => resolveAudienceText(audience, channel.name, rolloutPercent))
+        .join(' and ');
+    const progressionText = progression === null
+        ? ''
+        : `, progressing through ${resolveProgressionText(progression)}`;
+    return `${resolveReleaseText(bundleSource)} at ${rolloutPercent} percent${progressionText}${isMandatory ? ', mandatory' : ''}: ${audienceText}`;
+}
+// The audience preview checks the conditions before anything is uploaded.
+async function fetchChannelAudiences(hotCodePush, appId, options, fingerprint, rolloutPercent) {
+    const channelReferences = options.channel === undefined || options.channel.length === 0
+        ? [undefined]
+        : options.channel;
+    const audienceQuery = buildAudienceQuery(options, fingerprint, rolloutPercent);
+    const projectConfig = readProjectConfig(options.config);
+    return Promise.all(channelReferences.map(async (channelReference) => {
+        const channel = await hotCodePush.apps.channels.get({
+            appId,
+            channelId: await fetchChannelId(hotCodePush, appId, { ...options, channel: channelReference }, projectConfig),
+        });
+        const audience = await hotCodePush.apps.channels.audience.get({
+            ...audienceQuery,
+            appId: channel.appId,
+            channelId: channel.id,
+        });
+        return { audience, channel };
+    }));
+}
+// Mirrors the API, which releases the newest active release of that channel.
+async function fetchSourceRelease(hotCodePush, appId, reference) {
+    const sourceChannel = await hotCodePush.apps.channels.get({
+        appId,
+        channelId: await fetchResourceId('channel', reference, () => fetchChannels(hotCodePush, appId), '--from-channel'),
+    });
+    const sourceRelease = (await fetchReleaseLog(hotCodePush, sourceChannel)).find(({ status }) => status === 'active');
+    if (sourceRelease === undefined) {
+        throw new InvalidParameterError(`The channel ${sourceChannel.name} from --from-channel serves no active release.`);
+    }
+    const bundle = sourceRelease.bundle ??
+        (await hotCodePush.apps.bundles.get({
+            appId,
+            bundleId: sourceRelease.bundleId,
+        }));
+    return { bundle, sourceChannel, sourceRelease };
+}
+// A dry run still hashes a web build and checks the size limit, but uploads nothing.
+async function printDryRun(bundleSource, channelAudiences, consequence, options) {
+    if ('bundleUploads' in bundleSource) {
+        for (const bundleUpload of bundleSource.bundleUploads) {
+            assertWithinBundleBytesLimit(await collectUploadFiles(bundleUpload));
+        }
+    }
+    printAudienceWarnings(channelAudiences);
+    if (options.json) {
+        printJson(channelAudiences.map(({ audience, channel }) => ({
+            ...audience,
+            channelId: channel.id,
+        })));
+        return;
+    }
+    console.log(`Dry run, nothing published: this ${consequence}.`);
+}
+// Each channel warns once, however many platform bundles the release carries.
+function printAudienceWarnings(channelAudiences) {
+    for (const { audience } of channelAudiences) {
+        printWarnings(audience.warnings);
+    }
+}
+// The upload runs only once the release is confirmed.
+async function resolveBundleSource(hotCodePush, options, packagingDirectoryPath) {
+    const sourceFlags = [
+        options.bundle === undefined ? undefined : '--bundle',
+        options.fromChannel === undefined ? undefined : '--from-channel',
+        options.path === undefined ? undefined : '--path',
+    ].filter(flag => flag !== undefined);
+    if (sourceFlags.length > 1) {
+        throw new InvalidParameterError(`The flags ${sourceFlags.join(' and ')} were passed together.`, 'Pass one of them: the bundle to release, the channel to release from or the build to upload.');
+    }
+    if (options.bundle === undefined && options.fromChannel === undefined) {
+        return resolveUploadBundleOptions(hotCodePush, options, packagingDirectoryPath, { isDryRun: options.dryRun });
+    }
+    const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+    return options.fromChannel === undefined
+        ? { bundle: await fetchBundle(hotCodePush, appId, options) }
+        : fetchSourceRelease(hotCodePush, appId, options.fromChannel);
+}
+async function resolveReleasedBundles(hotCodePush, bundleSource) {
+    if ('bundle' in bundleSource) {
+        return [bundleSource.bundle];
+    }
+    const bundles = [];
+    for (const uploadBundleOptions of bundleSource.bundleUploads) {
+        bundles.push((await uploadBundle(hotCodePush, uploadBundleOptions)).bundle);
+    }
+    return bundles;
+}
+function resolveReleaseText(bundleSource) {
+    if ('bundleUploads' in bundleSource) {
+        return resolveUploadText(bundleSource.bundleUploads);
+    }
+    const bundleText = `releases bundle ${resolveBundleLabel(bundleSource.bundle)}`;
+    return 'sourceChannel' in bundleSource
+        ? `${bundleText}, release #${bundleSource.sourceRelease.number} of ${bundleSource.sourceChannel.name},`
+        : bundleText;
+}
+// A build still to upload has no number yet, so it is named by its version label.
+// One bundle for both platforms is the web build. Per-platform bundles are named by their platform.
+function resolveUploadText(bundleUploads) {
+    const bundleVersion = bundleUploads[0]?.bundleVersion ?? '';
+    const platformTexts = bundleUploads.map(({ platforms }) => platforms.join(' and '));
+    if (bundleUploads.length === 1 && platformTexts[0]?.includes(' and ')) {
+        return `uploads the web build as ${bundleVersion} and releases it`;
+    }
+    return bundleUploads.length === 1
+        ? `uploads the ${platformTexts[0]} bundle as ${bundleVersion} and releases it`
+        : `uploads the ${platformTexts.join(' and ')} bundles as ${bundleVersion} and releases each`;
+}
+// A project has one native contract, whatever the platform.
+function resolveSourceFingerprint(bundleSource) {
+    return 'bundle' in bundleSource
+        ? bundleSource.bundle.fingerprint
+        : (bundleSource.bundleUploads[0]?.fingerprint ?? null);
+}

package/dist/commands/release/get.js

@@ -0,0 +1,81 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveEffectiveFailurePolicy, resolveFailurePolicyDetails, } from '../../utils/channel-fields.js';
+import { defineCommand } from '../../utils/command.js';
+import { resolveReleaseDeviceCount } from '../../utils/fleet.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { resolveProgressionStepText, resolveProgressionText, } from '../../utils/progression.js';
+import { fetchReleaseInChannel, releaseOptionShape, resolveReleaseBundleLabel, } from '../../utils/release-resolution.js';
+import { channelOptionShape } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Print a release with its rollout, its progression, its effective auto-pause policy, its status and its counters: applied, confirmed and failed by reason.',
+    examples: [
+        'hotcodepush release get --release 43',
+        'hotcodepush release get --channel staging --release 43 --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...releaseOptionShape,
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+        if (options.json) {
+            printJson(release);
+            return;
+        }
+        const fleet = await hotCodePush.apps.statistics.fleet.get({
+            appId: channel.appId,
+            channelId: channel.id,
+        });
+        printDetails([
+            ['ID', release.id],
+            ['Number', `#${release.number}`],
+            ['Channel', channel.name],
+            ['Bundle', `${resolveReleaseBundleLabel(release)} (${release.bundleId})`],
+            ['Status', resolveStatusText(release)],
+            ['Rollout', `${release.rolloutPercent}%`],
+            ...resolveProgressionDetails(release),
+            ...resolveFailurePolicyDetails(resolveEffectiveFailurePolicy(release, channel)),
+            ['Mandatory', release.isMandatory ? 'yes' : 'no'],
+            ['Notes', release.notes ?? 'none'],
+            ['Rolled back from', release.rolledBackFromReleaseId ?? 'nothing'],
+            ['Live', release.liveAt ?? 'not yet'],
+            ['Devices', String(resolveReleaseDeviceCount(fleet, release.id))],
+            ...resolveCounterDetails(release),
+            ['Created', release.createdAt],
+        ]);
+    },
+});
+function resolveCounterDetails({ releaseCounters, }) {
+    if (releaseCounters === undefined) {
+        return [];
+    }
+    return [
+        ['Applied', String(releaseCounters.appliedUpdateCount)],
+        ['Confirmed', String(releaseCounters.confirmedUpdateCount)],
+        ['Download failures', String(releaseCounters.downloadFailureCount)],
+        ['Verification failures', String(releaseCounters.verificationFailureCount)],
+        ['Crash failures', String(releaseCounters.crashFailureCount)],
+        [
+            'Readiness timeout failures',
+            String(releaseCounters.readinessTimeoutFailureCount),
+        ],
+        ['Reported failures', String(releaseCounters.reportedFailureCount)],
+    ];
+}
+function resolveProgressionDetails(release) {
+    const { progression } = release;
+    if (progression === null) {
+        return [['Progression', 'none']];
+    }
+    return [
+        ['Progression', resolveProgressionText(progression)],
+        ['Progression step', resolveProgressionStepText(release, progression)],
+    ];
+}
+function resolveStatusText(release) {
+    return release.status === 'paused' && release.pausedAt !== null
+        ? `paused since ${release.pausedAt}`
+        : release.status;
+}

package/dist/commands/release/list.js

@@ -0,0 +1,69 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { resolveReleaseDeviceCount } from '../../utils/fleet.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable, resolveDate } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { resolveProgressionStepText } from '../../utils/progression.js';
+import { resolveReleaseBundleLabel } from '../../utils/release-resolution.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List a channel's releases, newest first, with the progression and the devices on each.",
+    examples: [
+        'hotcodepush release list',
+        'hotcodepush release list --channel staging --json',
+    ],
+    options: defineCommandOptions({ ...channelOptionShape, ...paginationShape }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const listedReleases = await hotCodePush.apps.releases.list({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+            limit: options.limit,
+            offset: options.offset,
+            relations: ['bundle', 'releaseCounters'],
+        });
+        const nextOffset = resolveNextOffset(listedReleases.length, options);
+        if (options.json) {
+            printJson({ nextOffset, releases: listedReleases });
+            return;
+        }
+        const fleet = await hotCodePush.apps.statistics.fleet.get({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        printTable({
+            emptyText: `No releases in channel ${fetchedChannel.name}.`,
+            headers: [
+                'NUMBER',
+                'BUNDLE',
+                'STATUS',
+                'ROLLOUT',
+                'PROGRESSION',
+                'MANDATORY',
+                'DEVICES',
+                'LIVE',
+                'CREATED',
+            ],
+            nextOffset,
+            rows: listedReleases.map(release => [
+                `#${release.number}`,
+                resolveReleaseBundleLabel(release),
+                release.status,
+                `${release.rolloutPercent}%`,
+                resolveProgressionCell(release),
+                release.isMandatory ? 'yes' : 'no',
+                String(resolveReleaseDeviceCount(fleet, release.id)),
+                release.liveAt === null ? 'pending' : resolveDate(release.liveAt),
+                resolveDate(release.createdAt),
+            ]),
+        });
+    },
+});
+function resolveProgressionCell(release) {
+    const { progression } = release;
+    return progression === null
+        ? 'none'
+        : `${progression.rolloutPercents.join(',')}% · ${resolveProgressionStepText(release, progression)}`;
+}

package/dist/commands/release/pause.js

@@ -0,0 +1,36 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchReleaseInChannel, releaseOptionShape, } from '../../utils/release-resolution.js';
+import { channelOptionShape } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Pause a release: devices on it keep it, and nobody new gets it until it is resumed.',
+    examples: [
+        'hotcodepush release pause --release 43',
+        'hotcodepush release pause --channel staging --release 43 --yes --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...releaseOptionShape,
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`pauses release #${release.number} of ${channel.name}: devices on it keep it and no new device gets it`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const pausedRelease = await hotCodePush.apps.releases.pause({
+            appId: channel.appId,
+            releaseId: release.id,
+        });
+        if (options.json) {
+            printJson(pausedRelease);
+        }
+        else {
+            console.log(`Paused release #${pausedRelease.number} of ${channel.name} (${pausedRelease.id}).`);
+        }
+    },
+});

package/dist/commands/release/resume.js

@@ -0,0 +1,36 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchReleaseInChannel, releaseOptionShape, } from '../../utils/release-resolution.js';
+import { channelOptionShape } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Resume a paused release: devices get it again, and a new auto-pause window starts.',
+    examples: [
+        'hotcodepush release resume --release 43',
+        'hotcodepush release resume --channel staging --release 43 --yes --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...releaseOptionShape,
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`resumes release #${release.number} of ${channel.name}: devices get it again and a new auto-pause window starts`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const resumedRelease = await hotCodePush.apps.releases.resume({
+            appId: channel.appId,
+            releaseId: release.id,
+        });
+        if (options.json) {
+            printJson(resumedRelease);
+        }
+        else {
+            console.log(`Resumed release #${resumedRelease.number} of ${channel.name} (${resumedRelease.id}).`);
+        }
+    },
+});