hotcodepush 0.0.1 → 0.2.0

package/dist/commands/release/revoke.js

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { fetchBundle } from '../../utils/bundle-resolution.js';
+import { defineCommand } from '../../utils/command.js';
+import { printWarning } from '../../utils/diagnostics.js';
+import { InvalidParameterError } from '../../utils/errors.js';
+import { resolveReleaseDeviceCount } from '../../utils/fleet.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, resolveQuantityText } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchReleaseInChannel, fetchReleaseLog, releaseOptionShape, } from '../../utils/release-resolution.js';
+import { channelOptionShape, fetchAppId, fetchChannel, } from '../../utils/resource-resolution.js';
+// The limit of the bulk route.
+const MAX_RELEASE_IDS_PER_REVOCATION = 100;
+export default defineCommand({
+    description: 'Revoke releases for good: devices on them move to the newest older release they qualify for or the embedded bundle.',
+    examples: [
+        'hotcodepush release revoke --release 43',
+        'hotcodepush release revoke --channel staging --release-from 40 --yes --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...releaseOptionShape,
+        all: z
+            .boolean()
+            .optional()
+            .describe('Every release of the channel. Its devices return to the embedded bundle.'),
+        bundle: z
+            .string()
+            .optional()
+            .describe("Every release of this bundle, by number or id, across the app's channels. Takes no --channel."),
+        releaseFrom: z.coerce
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('The first release revoked, by number, inclusive: that one and every newer one of the channel.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const revocations = await fetchRevocations(hotCodePush, options);
+        const [firstRevocation] = revocations;
+        if (firstRevocation === undefined ||
+            revocations.every(({ revokedReleases }) => revokedReleases.length === 0)) {
+            printNothingToRevoke(options.json);
+            return;
+        }
+        const fleet = await hotCodePush.apps.statistics.fleet.get({
+            appId: firstRevocation.channel.appId,
+        });
+        for (const pausedText of resolvePausedLandingTexts(revocations, fleet)) {
+            printWarning(pausedText);
+        }
+        const isConfirmed = await confirmConsequence(resolveRevocationConsequence(revocations, fleet), options);
+        if (!isConfirmed) {
+            return;
+        }
+        const answers = [];
+        for (const { channel, request } of revocations) {
+            answers.push({
+                channel,
+                releases: await fetchRevocation(hotCodePush, channel, request),
+            });
+        }
+        if (options.json) {
+            printJson(answers.flatMap(({ releases }) => releases));
+            return;
+        }
+        for (const { channel, releases } of answers) {
+            console.log(`Revoked ${resolveReleasesText(releases)} of ${channel.name}${releases.length === 1 ? ` (${releases[0]?.id})` : ''}.`);
+        }
+    },
+});
+async function fetchRevocation(hotCodePush, channel, request) {
+    if ('releaseId' in request) {
+        return [
+            await hotCodePush.apps.releases.revoke({
+                appId: channel.appId,
+                releaseId: request.releaseId,
+            }),
+        ];
+    }
+    const revokedReleases = [];
+    for (const releaseIds of resolveReleaseIdPages(request.releaseIds)) {
+        revokedReleases.push(...(await hotCodePush.apps.channels.releases.revoke({
+            appId: channel.appId,
+            channelId: channel.id,
+            releaseIds,
+        })));
+    }
+    return revokedReleases.sort((left, right) => right.number - left.number);
+}
+async function fetchRevocations(hotCodePush, options) {
+    const formFlags = [
+        options.all ? '--all' : undefined,
+        options.bundle === undefined ? undefined : '--bundle',
+        options.release === undefined ? undefined : '--release',
+        options.releaseFrom === undefined ? undefined : '--release-from',
+    ].filter(flag => flag !== undefined);
+    if (formFlags.length > 1) {
+        throw new InvalidParameterError(`The flags ${formFlags.join(' and ')} were passed together.`, 'Pass one of them.');
+    }
+    if (options.bundle !== undefined) {
+        if (options.channel !== undefined) {
+            throw new InvalidParameterError("With --bundle, the bundle's releases are revoked in every channel, so --channel does not apply.", 'Pass --bundle alone.');
+        }
+        return fetchBundleRevocations(hotCodePush, options);
+    }
+    if (options.all || options.releaseFrom !== undefined) {
+        const fromNumber = options.releaseFrom ?? 1;
+        const channel = await fetchChannel(hotCodePush, options);
+        const releaseLog = await fetchReleaseLog(hotCodePush, channel);
+        const revokedReleases = releaseLog.filter(({ number, status }) => number >= fromNumber && status !== 'revoked');
+        return [
+            {
+                channel,
+                releaseLog,
+                request: { releaseIds: revokedReleases.map(({ id }) => id) },
+                revokedReleases,
+            },
+        ];
+    }
+    const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+    return [
+        {
+            channel,
+            releaseLog: await fetchReleaseLog(hotCodePush, channel),
+            request: { releaseId: release.id },
+            revokedReleases: [release],
+        },
+    ];
+}
+async function fetchBundleRevocations(hotCodePush, options) {
+    const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+    const bundle = await fetchBundle(hotCodePush, appId, options);
+    const pendingReleases = (await fetchAllPages(page => hotCodePush.apps.releases.list({
+        appId,
+        bundleId: bundle.id,
+        relations: ['bundle', 'channel'],
+        ...page,
+    }))).filter(({ status }) => status !== 'revoked');
+    const channels = new Map();
+    for (const { channel } of pendingReleases) {
+        if (channel !== undefined) {
+            channels.set(channel.id, channel);
+        }
+    }
+    return Promise.all([...channels.values()].map(async (channel) => {
+        const revokedReleases = pendingReleases.filter(({ channelId }) => channelId === channel.id);
+        return {
+            channel,
+            releaseLog: await fetchReleaseLog(hotCodePush, channel),
+            request: { releaseIds: revokedReleases.map(({ id }) => id) },
+            revokedReleases,
+        };
+    }));
+}
+function printNothingToRevoke(isJson) {
+    if (isJson) {
+        printJson([]);
+        return;
+    }
+    console.log('Nothing to revoke: no release named is active or paused.');
+}
+// Mirrors the API: devices move to the newest active older release not revoked with it, or to the embedded bundle.
+function resolveDeviceMoves(revocation, fleet) {
+    const moves = new Map();
+    for (const revokedRelease of revocation.revokedReleases) {
+        const deviceCount = resolveReleaseDeviceCount(fleet, revokedRelease.id);
+        if (deviceCount === 0) {
+            continue;
+        }
+        const targetRelease = resolveOlderReleases(revocation, revokedRelease).find(({ status }) => status === 'active');
+        const key = targetRelease?.id ?? 'embedded';
+        const move = moves.get(key) ?? { deviceCount: 0, targetRelease };
+        move.deviceCount += deviceCount;
+        moves.set(key, move);
+    }
+    return [...moves.values()];
+}
+function resolveMovesText(revocation, fleet, isChannelNamed) {
+    const moves = resolveDeviceMoves(revocation, fleet);
+    if (moves.length === 0) {
+        return undefined;
+    }
+    const channelText = isChannelNamed ? ` in ${revocation.channel.name}` : '';
+    return moves
+        .map(({ deviceCount, targetRelease }) => {
+        const devicesText = resolveQuantityText(deviceCount, 'device');
+        return targetRelease === undefined
+            ? `${devicesText} return to the embedded bundle${channelText}`
+            : `${devicesText} move to release #${targetRelease.number}${channelText}`;
+    })
+        .join(' and ');
+}
+function resolveOlderReleases(revocation, revokedRelease) {
+    const revokedReleaseIds = new Set(revocation.revokedReleases.map(({ id }) => id));
+    return revocation.releaseLog
+        .filter(({ id, number, status }) => number < revokedRelease.number &&
+        status !== 'revoked' &&
+        !revokedReleaseIds.has(id))
+        .sort((left, right) => right.number - left.number);
+}
+// A paused release takes no device, so its devices land one release further back.
+function resolvePausedLandingTexts(revocations, fleet) {
+    const texts = new Set();
+    for (const revocation of revocations) {
+        for (const revokedRelease of revocation.revokedReleases) {
+            const [landingRelease] = resolveOlderReleases(revocation, revokedRelease);
+            if (resolveReleaseDeviceCount(fleet, revokedRelease.id) > 0 &&
+                landingRelease?.status === 'paused') {
+                texts.add(`release #${landingRelease.number} of ${revocation.channel.name} is paused, so the devices that would land on it land one further back`);
+            }
+        }
+    }
+    return [...texts];
+}
+function resolveRevocationConsequence(revocations, fleet) {
+    const isChannelNamed = revocations.length > 1;
+    const releasesText = revocations
+        .map(({ channel, revokedReleases }) => `${resolveReleasesText(revokedReleases)} of ${channel.name}`)
+        .join(' and ');
+    const movesText = revocations
+        .map(revocation => resolveMovesText(revocation, fleet, isChannelNamed))
+        .filter(text => text !== undefined)
+        .join(', ') || 'no device runs them';
+    const bundleNumbers = new Set(revocations.flatMap(({ revokedReleases }) => revokedReleases.map(({ bundle }) => bundle?.number)));
+    const [bundleNumber] = bundleNumbers;
+    const reReleaseText = bundleNumbers.size === 1 && bundleNumber !== undefined
+        ? `"release create --bundle ${bundleNumber}" releases its bundle again`
+        : '"release create --bundle <number>" releases a bundle again';
+    return `revokes ${releasesText} for good: ${movesText}. Revoked is final, and ${reReleaseText}`;
+}
+// The oldest page goes first, so devices never land on a newer release that a later page revokes.
+function resolveReleaseIdPages(newestFirstReleaseIds) {
+    const oldestFirstReleaseIds = newestFirstReleaseIds.toReversed();
+    const pages = [];
+    for (let start = 0; start < oldestFirstReleaseIds.length; start += MAX_RELEASE_IDS_PER_REVOCATION) {
+        pages.push(oldestFirstReleaseIds.slice(start, start + MAX_RELEASE_IDS_PER_REVOCATION));
+    }
+    return pages;
+}
+function resolveReleasesText(releases) {
+    const numberTexts = releases.map(({ number }) => `#${number}`);
+    if (numberTexts.length === 1) {
+        return `release ${numberTexts[0]}`;
+    }
+    if (numberTexts.length > 3) {
+        return resolveQuantityText(numberTexts.length, 'release');
+    }
+    return `releases ${numberTexts.slice(0, -1).join(', ')} and ${numberTexts.at(-1)}`;
+}

package/dist/commands/release/rollback.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { booleanFlagSchema } from '../../utils/boolean-flag.js';
+import { defineCommand } from '../../utils/command.js';
+import { InvalidParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { printReleasedLine } from '../../utils/release-output.js';
+import { fetchReleaseLog, resolveReleaseBundleLabel, resolveReleaseInLog, waitUntilLive, } from '../../utils/release-resolution.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Release the channel's previous bundle again, or the one of --to-release, as a new release.",
+    examples: [
+        'hotcodepush release rollback',
+        'hotcodepush release rollback --channel staging --to-release 41 --yes',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        mandatory: booleanFlagSchema
+            .optional()
+            .describe('Devices apply the rollback at once and restart, the default for an incident fix. Pass false to let them wait.'),
+        toRelease: z
+            .string()
+            .optional()
+            .describe("The release whose bundle comes back, by number or id. Defaults to the channel's previous one."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const releases = await fetchReleaseLog(hotCodePush, fetchedChannel);
+        const targetRelease = options.toRelease === undefined
+            ? resolvePreviousRelease(releases)
+            : resolveReleaseInLog(releases, options.toRelease, '--to-release');
+        const bundleLabel = resolveReleaseBundleLabel(targetRelease);
+        const isMandatory = options.mandatory ?? true;
+        const { deviceCount } = await hotCodePush.apps.statistics.fleet.get({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        const isConfirmed = await confirmConsequence(`rolls channel ${fetchedChannel.name} back to bundle ${bundleLabel} of release #${targetRelease.number} as a new ${isMandatory ? 'mandatory ' : ''}release, reaching its ${deviceCount} active devices`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const createdRelease = await hotCodePush.apps.channels.rollbacks.create({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+            isMandatory,
+            toReleaseId: targetRelease.id,
+        });
+        const liveRelease = await waitUntilLive(hotCodePush, fetchedChannel.appId, createdRelease.id);
+        if (options.json) {
+            printJson(liveRelease);
+        }
+        else {
+            printReleasedLine(liveRelease, fetchedChannel.name, bundleLabel);
+        }
+    },
+});
+// Mirrors the API rule for a rollback without a target.
+function resolvePreviousRelease(releases) {
+    const activeReleases = releases
+        .filter(({ status }) => status === 'active')
+        .sort((left, right) => right.number - left.number);
+    const currentRelease = activeReleases[0];
+    const previousRelease = activeReleases.find(release => currentRelease !== undefined &&
+        release.number < currentRelease.number &&
+        release.bundleId !== currentRelease.bundleId);
+    if (previousRelease === undefined) {
+        throw new InvalidParameterError('The channel has no earlier release to roll back to.', 'Name one with --to-release.');
+    }
+    return previousRelease;
+}

package/dist/commands/release/rollout.js

@@ -0,0 +1,63 @@
+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 { progressionShape, resolveProgression, resolveProgressionText, } from '../../utils/progression.js';
+import { confirmConsequence, promptText } from '../../utils/prompts.js';
+import { resolveProgressingText } from '../../utils/release-output.js';
+import { fetchReleaseInChannel, releaseOptionShape, } from '../../utils/release-resolution.js';
+import { channelOptionShape } from '../../utils/resource-resolution.js';
+const rolloutPercentSchema = z.coerce.number().int().min(0).max(100);
+export default defineCommand({
+    description: "Set a release's rollout percentage in either direction, or widen it step by step with --progression. A device that has the release keeps it.",
+    examples: [
+        'hotcodepush release rollout --release 43 --rollout-percent 50',
+        'hotcodepush release rollout --channel staging --release 43 --rollout-percent 10 --progression --yes',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...progressionShape,
+        ...releaseOptionShape,
+        rolloutPercent: rolloutPercentSchema
+            .optional()
+            .describe("The share of devices the release reaches from now on, 0 to 100. With --progression it is where the schedule starts. Defaults to the release's own percentage."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const progression = resolveProgression(options);
+        const rolloutPercent = options.rolloutPercent ??
+            (progression === null ? await promptRolloutPercent(options) : undefined);
+        const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(resolveRolloutConsequence(release, channel.name, rolloutPercent ?? release.rolloutPercent, progression), options);
+        if (!isConfirmed) {
+            return;
+        }
+        const updatedRelease = await hotCodePush.apps.releases.update({
+            appId: channel.appId,
+            progression: progression ?? undefined,
+            releaseId: release.id,
+            rolloutPercent,
+        });
+        if (options.json) {
+            printJson(updatedRelease);
+        }
+        else {
+            console.log(`Set release #${updatedRelease.number} of ${channel.name} to ${updatedRelease.rolloutPercent} percent${resolveProgressingText(updatedRelease)}.`);
+        }
+    },
+});
+async function promptRolloutPercent(options) {
+    const answer = await promptText('--rollout-percent', 'Which share of devices should the release reach, 0 to 100?', options);
+    return z
+        .object({ rolloutPercent: rolloutPercentSchema })
+        .parse({ rolloutPercent: answer }).rolloutPercent;
+}
+function resolveRolloutConsequence(release, channelName, rolloutPercent, progression) {
+    const releaseText = `release #${release.number} of ${channelName}`;
+    if (progression !== null) {
+        return `progresses ${releaseText} from ${rolloutPercent} percent through ${resolveProgressionText(progression)}: devices already on it keep it`;
+    }
+    const progressionEndText = release.progression === null ? '' : ', and its progression ends';
+    return `sets ${releaseText} to ${rolloutPercent} percent: devices already on it keep it, and no new device above ${rolloutPercent} percent gets it${progressionEndText}`;
+}

package/dist/commands/release/update.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { booleanFlagSchema } from '../../utils/boolean-flag.js';
+import { failurePolicyShape, releaseFailurePolicyClearShape, resolveFailurePolicy, } from '../../utils/channel-fields.js';
+import { defineCommand } from '../../utils/command.js';
+import { MissingParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { resolveNullableField } from '../../utils/nullable-field.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';
+const CLEARED_TEXT = 'cleared';
+export default defineCommand({
+    description: 'Edit a published release in place: flip the mandatory flag, rewrite or clear the notes, change or clear an auto-pause override.',
+    examples: [
+        'hotcodepush release update --release 43 --mandatory',
+        'hotcodepush release update --channel staging --release 43 --mandatory false --notes "cart fix" --yes',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...failurePolicyShape,
+        ...releaseFailurePolicyClearShape,
+        ...releaseOptionShape,
+        clearNotes: z.boolean().optional().describe('Sets the notes back to null.'),
+        mandatory: booleanFlagSchema
+            .optional()
+            .describe('Whether devices apply the release at once and restart. Pass false to turn it off.'),
+        notes: z.string().optional().describe('The new release notes.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const changes = resolveReleaseChanges(options);
+        const changeTexts = resolveChangeTexts(changes);
+        if (changeTexts.length === 0) {
+            throw new MissingParameterError('--mandatory, --notes, a --failure-* flag or a --clear-* flag', 'Pass at least one of them.');
+        }
+        const { channel, release } = await fetchReleaseInChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`changes release #${release.number} of ${channel.name}, ${changeTexts.join(' and ')}: devices see the change on their next check`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const updatedRelease = await hotCodePush.apps.releases.update({
+            ...changes,
+            appId: channel.appId,
+            releaseId: release.id,
+        });
+        if (options.json) {
+            printJson(updatedRelease);
+        }
+        else {
+            console.log(`Updated release #${updatedRelease.number} of ${channel.name} (${updatedRelease.id}).`);
+        }
+    },
+});
+// Uses the field order of `release get`.
+function resolveChangeTexts({ failureAction, failureMinimumUpdateCount, failureThresholdPercent, isMandatory, notes, }) {
+    const changeTexts = [];
+    if (failureThresholdPercent !== undefined) {
+        changeTexts.push(`failure threshold ${failureThresholdPercent === null ? CLEARED_TEXT : `${failureThresholdPercent}%`}`);
+    }
+    if (failureMinimumUpdateCount !== undefined) {
+        changeTexts.push(`failure minimum update count ${failureMinimumUpdateCount ?? CLEARED_TEXT}`);
+    }
+    if (failureAction !== undefined) {
+        changeTexts.push(`failure action ${failureAction ?? CLEARED_TEXT}`);
+    }
+    if (isMandatory !== undefined) {
+        changeTexts.push(`mandatory ${isMandatory ? 'on' : 'off'}`);
+    }
+    if (notes !== undefined) {
+        changeTexts.push(notes === null ? `notes ${CLEARED_TEXT}` : `notes "${notes}"`);
+    }
+    return changeTexts;
+}
+function resolveReleaseChanges(options) {
+    return {
+        ...resolveFailurePolicy(options),
+        isMandatory: options.mandatory,
+        notes: resolveNullableField(options.notes, options.clearNotes, 'notes'),
+    };
+}

package/dist/commands/resource-file/write.js

@@ -0,0 +1,78 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { buildStepShape, fetchChannelId, readBuildStep, resolveChannelIdByShape, resolveFailureText, resolveOfflineCause, writeBuildResourceFile, } from '../../utils/build-step.js';
+import { defineCommand } from '../../utils/command.js';
+import { printNotice, printWarning } from '../../utils/diagnostics.js';
+import { CliError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+// Only `binary create` gives an embedded bundle a version, the version of the binary.
+const UNVERSIONED_BUNDLE_VERSION = '';
+export default defineCommand({
+    description: 'The build step of every build that is no store build: writes the resource file the SDK reads, listing the embedded bundle, and creates no binary. Without a token, offline or with an API that cannot be reached, the channel name stays unresolved and one warning says so, in CI too.',
+    authentication: 'optional',
+    examples: [
+        'hotcodepush resource-file write --platform ios --embedded-bundle-path build/App.app/public --resource-file-path build/App.app/hotcodepush.json',
+        'hotcodepush resource-file write --platform android --embedded-bundle-path build/assets/public --resource-file-path build/assets/hotcodepush.json --json',
+    ],
+    options: defineCommandOptions(buildStepShape),
+    action: async (options) => {
+        const buildStep = await readBuildStep(options);
+        const { embeddedFiles, platform, resourceFilePath } = buildStep;
+        if (embeddedFiles === undefined) {
+            writeBuildResourceFile(buildStep, resolveChannelIdByShape(buildStep.channelReference), null);
+            printNotice(`The ${platform} build bundled no JavaScript, as a debug build served by the development server does. Wrote ${resourceFilePath} without an embedded bundle: over-the-air (OTA) updates are off in this build.`);
+            if (options.json) {
+                printJson({ resourceFilePath });
+            }
+            return;
+        }
+        const { channelId, skippedReason } = await resolveChannel(buildStep);
+        writeBuildResourceFile(buildStep, channelId, {
+            bundleVersion: UNVERSIONED_BUNDLE_VERSION,
+            files: embeddedFiles,
+            id: null,
+        });
+        if (skippedReason !== null) {
+            printWarning(skippedReason);
+        }
+        if (options.json) {
+            printJson({ resourceFilePath });
+            return;
+        }
+        console.log(`Wrote ${resourceFilePath} for ${platform}.`);
+    },
+});
+// Unlike `binary create`, this never fails offline or without a token, in a pipeline too.
+async function resolveChannel(buildStep) {
+    const channelIdByShape = resolveChannelIdByShape(buildStep.channelReference);
+    if (channelIdByShape !== null) {
+        return { channelId: channelIdByShape, skippedReason: null };
+    }
+    const offlineCause = resolveOfflineCause();
+    if (offlineCause !== undefined) {
+        return {
+            channelId: null,
+            skippedReason: resolveOfflineText(offlineCause),
+        };
+    }
+    try {
+        return {
+            channelId: await fetchChannelId(createApiClient(), buildStep),
+            skippedReason: null,
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        return {
+            channelId: null,
+            skippedReason: `The channel could not be resolved, so the build names none and takes no OTA updates: ${resolveFailureText(error)}`,
+        };
+    }
+}
+function resolveOfflineText(offlineCause) {
+    return offlineCause === 'offline-switch'
+        ? 'HOTCODEPUSH_OFFLINE is set, so the channel name was not resolved. The build names no channel and takes no OTA updates.'
+        : 'Not logged in, so the channel name was not resolved. The build names no channel and takes no OTA updates. Run "hotcodepush login" or set HOTCODEPUSH_TOKEN.';
+}

package/dist/commands/signing-key/add.js

@@ -0,0 +1,45 @@
+import { resolve } from 'node:path';
+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 { locateProjectConfig } from '../../utils/project-config.js';
+import { promptText } from '../../utils/prompts.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+import { readSigningKeyPairFile } from '../../utils/signing-private-key.js';
+import { addPublicKeyToProjectConfig, resolvePublicKeyListingText, UPLOAD_SIGNING_TEXT, } from './create.js';
+export default defineCommand({
+    description: 'Add the public key of a key pair you already have, from its private key file, which stays where it is: from then on the app releases only signed bundles.',
+    examples: [
+        'hotcodepush signing-key add --private-key-path my-app-private-key.pem',
+        'hotcodepush signing-key add --app "My App" --private-key-path my-app-private-key.pem --json',
+    ],
+    options: defineCommandOptions({
+        privateKeyPath: z
+            .string()
+            .optional()
+            .describe('The private key file of the pair, a PEM of PKCS #8 or PKCS #1, read on this machine. Its public key is derived from it.'),
+    }),
+    action: async (options) => {
+        const privateKeyPath = resolve(options.privateKeyPath ??
+            (await promptText('--private-key-path', 'Which private key file?', options)));
+        // Read before any request, so a key that is too small or not RSA is refused first.
+        const { publicKey } = await readSigningKeyPairFile(privateKeyPath);
+        const hotCodePush = createApiClient();
+        const projectConfigLocation = locateProjectConfig(options.config);
+        const appId = await fetchAppId(hotCodePush, options, projectConfigLocation.projectConfig);
+        const createdSigningKey = await hotCodePush.apps.signingKeys.create({
+            appId,
+            publicKey,
+        });
+        const isConfigured = addPublicKeyToProjectConfig(projectConfigLocation, appId, publicKey);
+        if (options.json) {
+            printJson(createdSigningKey);
+            return;
+        }
+        console.log(`Added signing key ${createdSigningKey.keyId} (${createdSigningKey.id}).`);
+        console.log(resolvePublicKeyListingText(isConfigured, publicKey));
+        console.log(UPLOAD_SIGNING_TEXT);
+    },
+});