hotcodepush 0.0.1 → 0.1.0

package/dist/utils/progression.js

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import { InvalidParameterError } from './errors.js';
+const DEFAULT_PROGRESSION = {
+    rolloutPercents: [10, 50, 100],
+    stepMinimumSeconds: 3600,
+    stepMinimumUpdateCount: 50,
+};
+// Parses `10,50,100` in the schema, so a wrong percentage is reported under the flag name.
+const percentageListSchema = z
+    .string()
+    .transform(value => value.split(',').map(percentage => percentage.trim()))
+    .pipe(z.array(z.coerce.number().int()));
+// The API validates the schedule itself.
+export const progressionShape = {
+    progression: z
+        .boolean()
+        .optional()
+        .describe('Widen the rollout step by step while the release stays healthy: 10, 50 and 100 percent by default, each step after at least an hour and 50 applied updates.'),
+    progressionMinimumSeconds: z.coerce
+        .number()
+        .int()
+        .optional()
+        .describe('The seconds a step lasts at least before the next one, with --progression; 3600 by default.'),
+    progressionMinimumUpdateCount: z.coerce
+        .number()
+        .int()
+        .optional()
+        .describe('The applied updates each step needs before the next one, with --progression; 50 by default.'),
+    progressionRolloutPercents: percentageListSchema
+        .optional()
+        .describe('The percentages the rollout widens through, rising, the last above the starting rollout, with --progression; 10,50,100 by default.'),
+};
+// A schedule flag without `--progression` is refused rather than taken as one.
+export function resolveProgression(options) {
+    if (!options.progression) {
+        assertNoProgressionFlags(options);
+        return null;
+    }
+    return {
+        rolloutPercents: options.progressionRolloutPercents ?? DEFAULT_PROGRESSION.rolloutPercents,
+        stepMinimumSeconds: options.progressionMinimumSeconds ??
+            DEFAULT_PROGRESSION.stepMinimumSeconds,
+        stepMinimumUpdateCount: options.progressionMinimumUpdateCount ??
+            DEFAULT_PROGRESSION.stepMinimumUpdateCount,
+    };
+}
+// Mirrors how the progression job of the API reads the release.
+// Nothing widens a paused or revoked release, so it has no step.
+export function resolveProgressionStep(release) {
+    const { progression, progressionStepStartedAt, releaseCounters } = release;
+    if (progression === null || release.status !== 'active') {
+        return null;
+    }
+    const number = progression.rolloutPercents.filter(percentage => percentage <= release.rolloutPercent).length;
+    if (number === progression.rolloutPercents.length) {
+        return null;
+    }
+    const appliedUpdateCount = progressionStepStartedAt === null || releaseCounters === undefined
+        ? 0
+        : releaseCounters.appliedUpdateCount -
+            release.stepStartAppliedUpdateCount;
+    if (progressionStepStartedAt === null ||
+        appliedUpdateCount < progression.stepMinimumUpdateCount) {
+        return {
+            gate: {
+                appliedUpdateCount,
+                requiredUpdateCount: progression.stepMinimumUpdateCount,
+                type: 'sample',
+            },
+            number,
+        };
+    }
+    return {
+        gate: {
+            readyAt: new Date(Date.parse(progressionStepStartedAt) +
+                progression.stepMinimumSeconds * 1000).toISOString(),
+            type: 'time',
+        },
+        number,
+    };
+}
+export function resolveProgressionStepText(release, progression) {
+    const progressionStep = resolveProgressionStep(release);
+    if (progressionStep !== null) {
+        return `${progressionStep.number} of ${progression.rolloutPercents.length}, ${resolveGateText(progressionStep.gate)}`;
+    }
+    switch (release.status) {
+        case 'active':
+            return 'complete';
+        case 'paused':
+            return 'held while paused';
+        case 'revoked':
+            return 'ended by the revocation';
+    }
+}
+export function resolveProgressionText({ rolloutPercents, stepMinimumSeconds, stepMinimumUpdateCount, }) {
+    return `${rolloutPercents.join(', ')} percent, each step at least ${stepMinimumSeconds} seconds and ${stepMinimumUpdateCount} applied updates`;
+}
+function assertNoProgressionFlags(options) {
+    const progressionFlags = [
+        options.progressionMinimumSeconds === undefined
+            ? undefined
+            : '--progression-minimum-seconds',
+        options.progressionMinimumUpdateCount === undefined
+            ? undefined
+            : '--progression-minimum-update-count',
+        options.progressionRolloutPercents === undefined
+            ? undefined
+            : '--progression-rollout-percents',
+    ].filter(flag => flag !== undefined);
+    if (progressionFlags.length > 0) {
+        throw new InvalidParameterError(`The schedule's flags ${progressionFlags.join(' and ')} apply only with --progression.`, 'Pass --progression to give the release a schedule.');
+    }
+}
+function resolveGateText(gate) {
+    return gate.type === 'sample'
+        ? `Waiting on updates: ${gate.appliedUpdateCount} of ${gate.requiredUpdateCount} applied`
+        : `ready at ${gate.readyAt}`;
+}

package/dist/utils/project-config.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { ProjectConfigurationSchema } from '@hotcodepush/protocol';
+import { z } from 'zod';
+import { PROJECT_CONFIG_FILE_NAME } from '../config/consts.js';
+import { InvalidParameterError } from './errors.js';
+import { readJsonFile, stringifyLikeSource } from './json-file.js';
+export const ID_SCHEMA = z.guid();
+// The file comes with the repository, and the id reaches console URLs, the browser and the resource file.
+export function assertProjectConfigAppId(appId) {
+    if (!ID_SCHEMA.safeParse(appId).success) {
+        throw new InvalidParameterError(`The appId in ${PROJECT_CONFIG_FILE_NAME} is not an id.`, 'Set appId to the id "hotcodepush app list" prints.');
+    }
+}
+export function resolveProjectChannel(projectConfig) {
+    return (projectConfig.channel ??
+        ProjectConfigurationSchema.shape.channel.parse(undefined));
+}
+// Walks up from the working directory to the nearest file, the way git finds its root.
+export function readProjectConfig(configPath) {
+    return locateProjectConfig(configPath).projectConfig;
+}
+// Without a file, the working directory is the project root.
+export function locateProjectConfig(configPath) {
+    const fileLocation = locateProjectConfigFile(configPath);
+    return {
+        ...fileLocation,
+        projectConfig: fileLocation.filePath === undefined
+            ? undefined
+            : readProjectConfigFile(fileLocation.filePath),
+    };
+}
+// The file is not read yet, so `doctor` can report one that does not parse.
+export function locateProjectConfigFile(configPath) {
+    if (configPath !== undefined && !existsSync(configPath)) {
+        throw new InvalidParameterError(`The file ${configPath} from --config does not exist.`);
+    }
+    const filePath = configPath === undefined
+        ? findProjectConfigFilePath(process.cwd())
+        : resolve(configPath);
+    return {
+        directoryPath: filePath === undefined ? process.cwd() : dirname(filePath),
+        filePath,
+    };
+}
+export function readProjectConfigFile(filePath) {
+    return readJsonFile(filePath);
+}
+export function writeProjectConfig(filePath, projectConfig) {
+    writeFileSync(filePath, stringifyLikeSource(projectConfig, readFileSync(filePath, 'utf8')));
+}
+function findProjectConfigFilePath(directoryPath) {
+    const filePath = join(directoryPath, PROJECT_CONFIG_FILE_NAME);
+    if (existsSync(filePath)) {
+        return filePath;
+    }
+    const parentDirectoryPath = dirname(directoryPath);
+    return parentDirectoryPath === directoryPath
+        ? undefined
+        : findProjectConfigFilePath(parentDirectoryPath);
+}

package/dist/utils/prompts.js

@@ -0,0 +1,53 @@
+import { confirm, isCancel, password, select, text } from '@clack/prompts';
+import { isInteractive } from './environment.js';
+import { ConfirmationRequiredError, MissingParameterError } from './errors.js';
+export async function confirmConsequence(consequence, options) {
+    if (options.yes) {
+        return true;
+    }
+    if (!isInteractive(options)) {
+        throw new ConfirmationRequiredError(consequence);
+    }
+    const answer = await confirm({
+        initialValue: false,
+        message: `This ${consequence}. Continue?`,
+    });
+    return answer === true;
+}
+export async function promptYesNo(message, options) {
+    if (!isInteractive(options)) {
+        return false;
+    }
+    const answer = await confirm({ initialValue: true, message });
+    return answer === true;
+}
+export async function promptSelect(flag, message, choices, options) {
+    if (choices.length === 0 || !isInteractive(options)) {
+        throw new MissingParameterError(flag);
+    }
+    // clack types an option through a conditional type that a generic value cannot satisfy.
+    const answer = await select({ message, options: choices });
+    if (isCancel(answer)) {
+        throw new MissingParameterError(flag);
+    }
+    return answer;
+}
+export function promptSecret(flag, message, options) {
+    return promptInput(password, flag, message, options);
+}
+export function promptText(flag, message, options) {
+    return promptInput(text, flag, message, options);
+}
+async function promptInput(ask, flag, message, options) {
+    if (!isInteractive(options)) {
+        throw new MissingParameterError(flag);
+    }
+    const answer = await ask({
+        message,
+        validate: value => (value?.trim() ? undefined : 'Enter a value.'),
+    });
+    if (isCancel(answer)) {
+        throw new MissingParameterError(flag);
+    }
+    return answer;
+}

package/dist/utils/react-native-project.js

@@ -0,0 +1,119 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { NativeProjectError } from './errors.js';
+import { resolveRefusedEdit } from './native-project-edit.js';
+const APP_DELEGATE_FILE_NAMES = ['AppDelegate.swift', 'AppDelegate.mm'];
+const BUNDLE_URL_CALL = 'HotCodePush.bundleURL()';
+const BUNDLE_URL_FIX = `Import HotcodepushReactNativeCodePush in the file that overrides bundleURL() and return ${BUNDLE_URL_CALL} from it where it returns the embedded bundle.`;
+const BUNDLE_URL_OVERRIDE = 'func bundleURL()';
+const EMBEDDED_BUNDLE_URL_CALL = 'Bundle.main.url(forResource: "main", withExtension: "jsbundle")';
+const OBJECTIVE_C_BUNDLE_URL_CALL = '[HotCodePush bundleURL]';
+const REACT_HOST_CLASS = 'com.hotcodepush.reactnative.HotCodePushReactHost';
+const REACT_HOST_EDIT_DESCRIPTION = 'HotCodePushReactHost in MainApplication.kt';
+const REACT_HOST_IMPORT = `import ${REACT_HOST_CLASS}.getDefaultReactHost`;
+const REACT_NATIVE_REACT_HOST_IMPORT = 'import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost';
+const SWIFT_MODULE_IMPORT = 'import HotcodepushReactNativeCodePush';
+// React Native 0.88's template overrides `bundleURL()` in `SceneDelegate.swift`, older ones in `AppDelegate.swift`.
+// The debug build's Metro line stays as it is.
+export function resolveBundleUrlEdit(iosProjectPath) {
+    if (!existsSync(iosProjectPath)) {
+        return undefined;
+    }
+    const appDelegateFilePath = findAppDelegateFilePath(iosProjectPath);
+    if (appDelegateFilePath === undefined ||
+        !appDelegateFilePath.endsWith('.swift')) {
+        return resolveRefusedBundleUrlEdit(iosProjectPath, appDelegateFilePath);
+    }
+    const sceneDelegateFilePath = join(dirname(appDelegateFilePath), 'SceneDelegate.swift');
+    const bundleUrlFilePath = [sceneDelegateFilePath, appDelegateFilePath].find(hasBundleUrlOverride);
+    const filePath = bundleUrlFilePath ?? appDelegateFilePath;
+    return {
+        description: `${BUNDLE_URL_CALL} in ${basename(filePath)}`,
+        filePath,
+        isApplied: () => readFileSync(filePath, 'utf8').includes(BUNDLE_URL_CALL),
+        apply: () => {
+            if (bundleUrlFilePath === undefined) {
+                throw new NativeProjectError(`Neither ${sceneDelegateFilePath} nor ${appDelegateFilePath} returns the template's main.jsbundle from bundleURL().`, BUNDLE_URL_FIX);
+            }
+            const source = readFileSync(filePath, 'utf8');
+            const lastImportLine = source
+                .split('\n')
+                .findLast(line => line.startsWith('import '));
+            if (!source.includes(EMBEDDED_BUNDLE_URL_CALL) ||
+                lastImportLine === undefined) {
+                throw new NativeProjectError(`The file ${filePath} does not return the template's main.jsbundle from bundleURL().`, `Import HotcodepushReactNativeCodePush in ${filePath} and return ${BUNDLE_URL_CALL} from bundleURL() where it returns the embedded bundle.`);
+            }
+            writeFileSync(filePath, source
+                .replace(lastImportLine, `${lastImportLine}\n${SWIFT_MODULE_IMPORT}`)
+                .replace(EMBEDDED_BUNDLE_URL_CALL, BUNDLE_URL_CALL));
+        },
+    };
+}
+// The SDK's `getDefaultReactHost` asks for the served bundle at every start and reload.
+// Only the import changes, so the call and its parameters stay.
+export function resolveReactHostEdit(androidProjectPath) {
+    if (!existsSync(androidProjectPath)) {
+        return undefined;
+    }
+    const sourceDirectoryPath = join(androidProjectPath, 'app', 'src', 'main', 'java');
+    const filePath = findFilePath(sourceDirectoryPath, 'MainApplication.kt');
+    if (filePath === undefined) {
+        return resolveRefusedReactHostEdit(androidProjectPath, findFilePath(sourceDirectoryPath, 'MainApplication.java'));
+    }
+    return {
+        description: REACT_HOST_EDIT_DESCRIPTION,
+        filePath,
+        isApplied: () => readFileSync(filePath, 'utf8').includes(REACT_HOST_IMPORT),
+        apply: () => {
+            const source = readFileSync(filePath, 'utf8');
+            if (!source.includes(REACT_NATIVE_REACT_HOST_IMPORT)) {
+                throw new NativeProjectError(`The file ${filePath} does not import the template's DefaultReactHost.getDefaultReactHost.`, resolveReactHostFix(filePath));
+            }
+            writeFileSync(filePath, source.replace(REACT_NATIVE_REACT_HOST_IMPORT, REACT_HOST_IMPORT));
+        },
+    };
+}
+// Templates before React Native 0.77 have an Objective-C app delegate.
+function findAppDelegateFilePath(iosProjectPath) {
+    const appDirectoryPaths = readdirSync(iosProjectPath, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && entry.name !== 'Pods')
+        .map(entry => join(iosProjectPath, entry.name));
+    return APP_DELEGATE_FILE_NAMES.flatMap(fileName => appDirectoryPaths.map(directoryPath => join(directoryPath, fileName))).find(filePath => existsSync(filePath));
+}
+function findFilePath(directoryPath, fileName) {
+    if (!existsSync(directoryPath)) {
+        return undefined;
+    }
+    for (const entry of readdirSync(directoryPath, { withFileTypes: true })) {
+        const entryPath = join(directoryPath, entry.name);
+        if (entry.isFile() && entry.name === fileName) {
+            return entryPath;
+        }
+        const foundPath = entry.isDirectory()
+            ? findFilePath(entryPath, fileName)
+            : undefined;
+        if (foundPath !== undefined) {
+            return foundPath;
+        }
+    }
+    return undefined;
+}
+function hasBundleUrlOverride(filePath) {
+    return (existsSync(filePath) &&
+        readFileSync(filePath, 'utf8').includes(BUNDLE_URL_OVERRIDE));
+}
+function resolveReactHostFix(location) {
+    return `Build the React host in ${location} with ${REACT_HOST_CLASS}.getDefaultReactHost, which takes DefaultReactHost.getDefaultReactHost's parameters.`;
+}
+function resolveRefusedBundleUrlEdit(iosProjectPath, objectiveCFilePath) {
+    if (objectiveCFilePath === undefined) {
+        return resolveRefusedEdit(`${BUNDLE_URL_CALL} in AppDelegate.swift`, iosProjectPath, new NativeProjectError(`The iOS project ${iosProjectPath} has no AppDelegate.swift in an app folder.`, BUNDLE_URL_FIX));
+    }
+    return resolveRefusedEdit(`${BUNDLE_URL_CALL} in ${basename(objectiveCFilePath)}`, objectiveCFilePath, new NativeProjectError(`The app delegate ${objectiveCFilePath} is Objective-C, and init edits only the Swift file that overrides bundleURL().`, `Import <HotcodepushReactNativeCodePush/HotcodepushReactNativeCodePush-Swift.h> in ${objectiveCFilePath} and return ${OBJECTIVE_C_BUNDLE_URL_CALL} from bundleURL where it returns the embedded bundle.`), OBJECTIVE_C_BUNDLE_URL_CALL);
+}
+function resolveRefusedReactHostEdit(androidProjectPath, javaFilePath) {
+    if (javaFilePath === undefined) {
+        return resolveRefusedEdit(REACT_HOST_EDIT_DESCRIPTION, androidProjectPath, new NativeProjectError(`The Android project ${androidProjectPath} has no MainApplication.kt in its app's sources.`, resolveReactHostFix("the app's Application class")));
+    }
+    return resolveRefusedEdit(REACT_HOST_EDIT_DESCRIPTION, javaFilePath, new NativeProjectError(`The file ${javaFilePath} is Java, and init edits only the MainApplication.kt of React Native's template.`, resolveReactHostFix(javaFilePath)), REACT_HOST_CLASS);
+}

package/dist/utils/release-conditions.js

@@ -0,0 +1,80 @@
+import { hashAttribute, hashDeviceId, isValidAttributeKey, isValidAttributeValue, } from '@hotcodepush/protocol';
+import { z } from 'zod';
+import { InvalidParameterError } from './errors.js';
+export const conditionOptionShape = {
+    attribute: z
+        .array(z.string())
+        .optional()
+        .describe('An attribute the app sets that the device must carry, key=value, repeatable.'),
+    binaryVersion: z
+        .string()
+        .optional()
+        .describe('The app versions served, a semver range such as ">=2.3.0 <3.0.0".'),
+    device: z
+        .array(z.string())
+        .optional()
+        .describe('A device the release is limited to, by id, repeatable.'),
+    osVersion: z
+        .string()
+        .optional()
+        .describe('The OS versions served, a range such as ">=17".'),
+};
+// A release of a bundle carries its fingerprint beside the conditions.
+export function buildAudienceQuery(options, fingerprint, rolloutPercent) {
+    return {
+        attribute: resolveAttributePairs(options.attribute).map(({ key, value }) => `${key}=${value}`),
+        binary: resolveList(options.binaryVersion),
+        device: options.device ?? [],
+        fingerprint: resolveList(fingerprint ?? undefined),
+        os: resolveList(options.osVersion),
+        rolloutPercent,
+    };
+}
+// Matches the index: attribute values and device ids are hashed, and all device ids share one condition.
+export function buildReleaseConditions(options, fingerprint) {
+    const deviceIds = options.device ?? [];
+    return [
+        ...resolveAttributePairs(options.attribute).map(({ key, value }) => ({
+            key,
+            type: 'attribute',
+            valueSha256: hashAttribute(key, value),
+        })),
+        ...resolveList(options.binaryVersion).map((range) => ({
+            range,
+            type: 'binary',
+        })),
+        ...(deviceIds.length === 0
+            ? []
+            : [
+                {
+                    hashedIds: deviceIds.map(hashDeviceId),
+                    type: 'device',
+                },
+            ]),
+        ...resolveList(fingerprint ?? undefined).map((fingerprint) => ({
+            fingerprint,
+            type: 'fingerprint',
+        })),
+        ...resolveList(options.osVersion).map((range) => ({
+            range,
+            type: 'os',
+        })),
+    ];
+}
+// The API requires the key to be an identifier and the value to be printable.
+export function resolveAttributePairs(attributes) {
+    return (attributes ?? []).map(pair => {
+        const separatorIndex = pair.indexOf('=');
+        const key = pair.slice(0, separatorIndex);
+        const value = pair.slice(separatorIndex + 1);
+        if (separatorIndex === -1 ||
+            !isValidAttributeKey(key) ||
+            !isValidAttributeValue(value)) {
+            throw new InvalidParameterError(`The value "${pair}" of --attribute is not a key=value pair.`, 'Pass key=value. The key takes letters, digits, _, - and . up to 64 characters, the value printable characters up to 256.');
+        }
+        return { key, value };
+    });
+}
+function resolveList(value) {
+    return value === undefined ? [] : [value];
+}

package/dist/utils/release-output.js

@@ -0,0 +1,13 @@
+export function printReleasedLine(release, channelName, bundleLabel) {
+    console.log(`Released bundle ${bundleLabel} to ${channelName} as release #${release.number} at ${release.rolloutPercent} percent${resolveProgressingText(release)}${resolveLiveText(release)}.`);
+}
+export function resolveProgressingText({ progression }) {
+    return progression === null
+        ? ''
+        : `, progressing through ${progression.rolloutPercents.join(', ')} percent`;
+}
+function resolveLiveText(release) {
+    return release.liveAt === null
+        ? '; not live yet, and "release get" shows when it is'
+        : `, live since ${release.liveAt}`;
+}

package/dist/utils/release-resolution.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { resolveBundleLabel } from './bundle-resolution.js';
+import { InvalidParameterError } from './errors.js';
+import { fetchAllPages } from './pagination.js';
+import { ID_SCHEMA } from './project-config.js';
+import { promptSelect } from './prompts.js';
+import { fetchChannel } from './resource-resolution.js';
+const LIVE_POLL_INTERVAL_MS = 1000;
+const LIVE_WAIT_MS = 60_000;
+const NUMBER_PATTERN = /^\d+$/;
+export const releaseOptionShape = {
+    release: z
+        .string()
+        .optional()
+        .describe('The release, by its number in the channel or by its id.'),
+};
+export async function fetchReleaseInChannel(hotCodePush, options) {
+    const channel = await fetchChannel(hotCodePush, options);
+    const releaseId = await resolveReleaseId(hotCodePush, channel, options);
+    const release = await hotCodePush.apps.releases.get({
+        appId: channel.appId,
+        relations: ['bundle', 'channel', 'releaseCounters'],
+        releaseId,
+    });
+    if (release.channelId !== channel.id) {
+        throw new InvalidParameterError(`The release ${releaseId} from --release is not in channel ${channel.name}.`);
+    }
+    return { channel, release };
+}
+export function fetchReleaseLog(hotCodePush, channel) {
+    return fetchAllPages(page => hotCodePush.apps.releases.list({
+        appId: channel.appId,
+        channelId: channel.id,
+        relations: ['bundle'],
+        ...page,
+    }));
+}
+export function resolveReleaseBundleLabel(release) {
+    return release.bundle === undefined
+        ? release.bundleId
+        : resolveBundleLabel(release.bundle);
+}
+export function resolveReleaseInLog(releases, reference, flag) {
+    const release = ID_SCHEMA.safeParse(reference).success
+        ? releases.find(({ id }) => id === reference)
+        : NUMBER_PATTERN.test(reference)
+            ? releases.find(({ number }) => number === Number(reference))
+            : undefined;
+    if (release === undefined) {
+        throw new InvalidParameterError(`The channel has no release "${reference}" from ${flag}.`, `Name a release of the channel by number or id with ${flag}.`);
+    }
+    return release;
+}
+// The materializer stamps `liveAt` once the index is written.
+// Returns the last read release after the deadline, so the caller can say it is still pending.
+export async function waitUntilLive(hotCodePush, appId, releaseId, relations) {
+    const deadline = Date.now() + LIVE_WAIT_MS;
+    for (;;) {
+        const release = await hotCodePush.apps.releases.get({
+            appId,
+            relations,
+            releaseId,
+        });
+        if (release.liveAt !== null || Date.now() >= deadline) {
+            return release;
+        }
+        await new Promise(resolve => setTimeout(resolve, LIVE_POLL_INTERVAL_MS));
+    }
+}
+async function resolveReleaseId(hotCodePush, channel, options) {
+    if (options.release !== undefined &&
+        ID_SCHEMA.safeParse(options.release).success) {
+        return options.release;
+    }
+    const releases = await fetchReleaseLog(hotCodePush, channel);
+    if (options.release !== undefined) {
+        return resolveReleaseInLog(releases, options.release, '--release').id;
+    }
+    return promptSelect('--release', 'Which release?', releases.map(release => ({
+        label: `#${release.number} · ${resolveReleaseBundleLabel(release)} (${release.status})`,
+        value: release.id,
+    })), options);
+}

package/dist/utils/resource-file.js

@@ -0,0 +1,81 @@
+import { createPublicKey } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { ConfigurationSchema, resolveSigningKeyId, SIGNING_KEY_BITS_MINIMUM, SigningPublicKeySchema, } from '@hotcodepush/protocol';
+import { PROJECT_CONFIG_FILE_NAME } from '../config/consts.js';
+import { InvalidParameterError } from './errors.js';
+// The manifest is the unsigned bundle manifest without patches, whether or not a binary was created.
+// The public keys take the form that the platform API imports.
+export function buildResourceFile({ builtAt, channelId, embeddedBundle, fingerprint, hosts, platform, projectConfig, }) {
+    return ConfigurationSchema.parse({
+        ...omitProjectOnlyKeys(projectConfig),
+        builtAt,
+        channelId,
+        embeddedBundleId: embeddedBundle?.id ?? null,
+        embeddedBundleManifest: embeddedBundle === null
+            ? null
+            : {
+                appId: projectConfig.appId,
+                bundleVersion: embeddedBundle.bundleVersion,
+                files: embeddedBundle.files.map(({ path, sha256, sizeBytes }) => ({
+                    path,
+                    sha256,
+                    sizeBytes,
+                })),
+                fingerprint,
+                keyId: null,
+                platforms: [platform],
+            },
+        fingerprint,
+        publicKeys: (projectConfig.publicKeys ?? []).map(publicKey => resolveDevicePublicKey(publicKey, platform)),
+        ...(hosts.filesBaseUrl === undefined
+            ? {}
+            : { filesBaseUrl: hosts.filesBaseUrl }),
+        ...(hosts.updatesBaseUrl === undefined
+            ? {}
+            : { updatesBaseUrl: hosts.updatesBaseUrl }),
+    });
+}
+export function writeResourceFile(filePath, configuration) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(configuration, null, 2)}\n`);
+}
+// The device imports the DER with its platform API and handles no ASN.1 itself.
+// iOS `SecKeyCreateWithData` takes PKCS #1 and Android `X509EncodedKeySpec` takes SPKI.
+function resolveDevicePublicKey(publicKey, platform) {
+    if (!SigningPublicKeySchema.safeParse(publicKey).success) {
+        throw buildUnusablePublicKeyError(publicKey);
+    }
+    let keyObject;
+    try {
+        keyObject = createPublicKey({
+            format: 'der',
+            key: Buffer.from(publicKey.slice(publicKey.indexOf(':') + 1), 'base64'),
+            type: 'spki',
+        });
+    }
+    catch (error) {
+        throw buildUnusablePublicKeyError(publicKey, error);
+    }
+    if (keyObject.asymmetricKeyType !== 'rsa' ||
+        (keyObject.asymmetricKeyDetails?.modulusLength ?? 0) <
+            SIGNING_KEY_BITS_MINIMUM) {
+        throw buildUnusablePublicKeyError(publicKey);
+    }
+    return {
+        der: keyObject
+            .export({ format: 'der', type: platform === 'ios' ? 'pkcs1' : 'spki' })
+            .toString('base64'),
+        keyId: resolveSigningKeyId(publicKey),
+    };
+}
+function buildUnusablePublicKeyError(publicKey, cause) {
+    return new InvalidParameterError(`The publicKeys in ${PROJECT_CONFIG_FILE_NAME} list ${publicKey.slice(0, 32)}…, which is not an rsa-v1_5-sha256 key of ${SIGNING_KEY_BITS_MINIMUM} bits or more.`, 'Replace it with the public key "hotcodepush signing-key create" writes.', cause);
+}
+// The resolved id replaces the channel, and only the CLI reads the fingerprint paths.
+function omitProjectOnlyKeys(projectConfig) {
+    const configuration = { ...projectConfig };
+    delete configuration.channel;
+    delete configuration.extraFingerprintPaths;
+    return configuration;
+}