hotcodepush 0.0.0 → 0.1.0

package/dist/commands/binary/get.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { isInteractive } from '../../utils/environment.js';
+import { MissingParameterError } from '../../utils/errors.js';
+import { resolveBinaryBucket, UNSEEN_IN_FLEET_WINDOW_TEXT, } from '../../utils/fleet.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { promptSelect } from '../../utils/prompts.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Print a binary, a store build whose build created it, with the bundle it ships and the devices running it.',
+    examples: [
+        'hotcodepush binary get --binary 6ba7b810-9dad-41d1-80b4-00c04fd430c8',
+        'hotcodepush binary get --binary 6ba7b810-9dad-41d1-80b4-00c04fd430c8 --json',
+    ],
+    options: defineCommandOptions({
+        binary: z.string().optional().describe('The binary, by id.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const fetchedBinary = await hotCodePush.apps.binaries.get({
+            appId,
+            binaryId: options.binary ?? (await promptBinaryId(hotCodePush, appId, options)),
+        });
+        if (options.json) {
+            printJson(fetchedBinary);
+            return;
+        }
+        const binaryBucket = resolveBinaryBucket(await hotCodePush.apps.statistics.fleet.get({ appId }), fetchedBinary.id);
+        printDetails([
+            ['ID', fetchedBinary.id],
+            ['Platform', fetchedBinary.platform],
+            ['Version', fetchedBinary.version],
+            ['Build', fetchedBinary.build],
+            ['Fingerprint', fetchedBinary.fingerprint ?? 'none'],
+            ['Bundle', fetchedBinary.bundleId],
+            ['Devices', String(binaryBucket?.deviceCount ?? 0)],
+            ['Last seen', binaryBucket?.lastSeenAt ?? UNSEEN_IN_FLEET_WINDOW_TEXT],
+            ['Created', fetchedBinary.createdAt],
+        ]);
+    },
+});
+async function promptBinaryId(hotCodePush, appId, options) {
+    if (!isInteractive(options)) {
+        throw new MissingParameterError('--binary');
+    }
+    const binaries = await fetchAllPages(page => hotCodePush.apps.binaries.list({ appId, ...page }));
+    return promptSelect('--binary', 'Which store build?', binaries.map(({ build, id, platform, version }) => ({
+        label: `${platform} ${version} (${build})`,
+        value: id,
+    })), options);
+}

package/dist/commands/binary/list.js

@@ -0,0 +1,58 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveBinaryBucket, UNSEEN_IN_FLEET_WINDOW_TEXT, } 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 { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'List the binaries, the store builds whose build created one, with the bundle each ships and the devices running it.',
+    examples: [
+        'hotcodepush binary list',
+        'hotcodepush binary list --app "My App" --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const listedBinaries = await hotCodePush.apps.binaries.list({
+            appId,
+            limit: options.limit,
+            offset: options.offset,
+        });
+        const nextOffset = resolveNextOffset(listedBinaries.length, options);
+        if (options.json) {
+            printJson({ binaries: listedBinaries, nextOffset });
+            return;
+        }
+        const fleet = await hotCodePush.apps.statistics.fleet.get({ appId });
+        printTable({
+            emptyText: 'No binaries; a store build creates one.',
+            headers: [
+                'ID',
+                'VERSION',
+                'BUILD',
+                'PLATFORM',
+                'BUNDLE',
+                'DEVICES',
+                'LAST SEEN',
+            ],
+            nextOffset,
+            rows: listedBinaries.map(({ build, bundleId, id, platform, version }) => {
+                const binaryBucket = resolveBinaryBucket(fleet, id);
+                return [
+                    id,
+                    version,
+                    build,
+                    platform,
+                    bundleId,
+                    String(binaryBucket?.deviceCount ?? 0),
+                    binaryBucket === undefined
+                        ? UNSEEN_IN_FLEET_WINDOW_TEXT
+                        : resolveDate(binaryBucket.lastSeenAt),
+                ];
+            }),
+        });
+    },
+});

package/dist/commands/bundle/delete.js

@@ -0,0 +1,35 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { bundleOptionShape, fetchBundle, resolveBundleLabel, } from '../../utils/bundle-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Delete a bundle now; one a release serves or a store build embeds is refused.',
+    examples: [
+        'hotcodepush bundle delete --bundle 17',
+        'hotcodepush bundle delete --bundle 17 --yes --json',
+    ],
+    options: defineCommandOptions(bundleOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const fetchedBundle = await fetchBundle(hotCodePush, appId, options);
+        const isConfirmed = await confirmConsequence(`deletes bundle ${resolveBundleLabel(fetchedBundle)} and its files now, not by retention`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.apps.bundles.delete({
+            appId,
+            bundleId: fetchedBundle.id,
+        });
+        if (options.json) {
+            printJson({ id: fetchedBundle.id, name: fetchedBundle.version });
+        }
+        else {
+            console.log(`Deleted bundle ${resolveBundleLabel(fetchedBundle)} (${fetchedBundle.id}).`);
+        }
+    },
+});

package/dist/commands/bundle/get.js

@@ -0,0 +1,63 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { bundleOptionShape, fetchBundle, } from '../../utils/bundle-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson, resolveQuantityText, } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { resolveByteText } from '../../utils/progress.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Print a bundle, by its number or id, with its deltas.',
+    examples: [
+        'hotcodepush bundle get --bundle 17',
+        'hotcodepush bundle get --bundle 17 --json',
+    ],
+    options: defineCommandOptions(bundleOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const fetchedBundle = await fetchBundle(hotCodePush, appId, options);
+        const fetchedDeltas = await fetchAllPages(page => hotCodePush.apps.bundles.deltas.list({
+            ...page,
+            appId,
+            bundleId: fetchedBundle.id,
+            relations: ['baseBundle'],
+        }));
+        if (options.json) {
+            printJson({ ...fetchedBundle, deltas: fetchedDeltas });
+            return;
+        }
+        printDetails([
+            ['ID', fetchedBundle.id],
+            [
+                'Number',
+                fetchedBundle.number === null ? 'none' : `#${fetchedBundle.number}`,
+            ],
+            ['Source', fetchedBundle.source],
+            ['Version', fetchedBundle.version],
+            ['Status', fetchedBundle.status],
+            ['Platforms', fetchedBundle.platforms.join(', ')],
+            ['Size', resolveByteText(fetchedBundle.sizeBytes)],
+            ['Deltas', resolveDeltasText(fetchedDeltas)],
+            ['Fingerprint', fetchedBundle.fingerprint ?? 'none'],
+            ['Commit', fetchedBundle.gitSha ?? 'unknown'],
+            ['Expires', fetchedBundle.expiresAt ?? 'in use'],
+            ['Created', fetchedBundle.createdAt],
+        ]);
+    },
+});
+function resolveDeltasText(deltas) {
+    if (deltas.length === 0) {
+        return 'none';
+    }
+    return deltas.map(resolveDeltaText).join('; ');
+}
+function resolveDeltaText({ baseBundle, patchCount, sizeBytes, status, }) {
+    const baseBundleNumber = baseBundle?.number ?? null;
+    const baseText = baseBundleNumber === null ? 'embedded' : `#${baseBundleNumber}`;
+    if (patchCount === null || sizeBytes === null) {
+        return `${baseText}: ${status}`;
+    }
+    return `${baseText}: ${resolveByteText(sizeBytes)}, ${resolveQuantityText(patchCount, 'patch', 'patches')}, ${status}`;
+}

package/dist/commands/bundle/list.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable, resolveDate } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { resolveByteText } from '../../utils/progress.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+const BUNDLE_SOURCES = ['all', 'binary', 'upload'];
+export default defineCommand({
+    description: "List an app's bundles, newest first: the uploaded ones by default, the ones binaries ship with --source binary, both with --source all.",
+    examples: [
+        'hotcodepush bundle list',
+        'hotcodepush bundle list --source all --bundle-version 1.4.2 --json',
+    ],
+    options: defineCommandOptions({
+        ...paginationShape,
+        bundleVersion: z
+            .string()
+            .optional()
+            .describe('Only the bundles carrying this version label.'),
+        source: z
+            .enum(BUNDLE_SOURCES)
+            .optional()
+            .describe('upload, the bundles a release can carry, by default; binary, the ones binaries ship, which have no number; or all.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const source = options.source ?? 'upload';
+        const listedBundles = await hotCodePush.apps.bundles.list({
+            appId: await fetchAppId(hotCodePush, options, readProjectConfig(options.config)),
+            limit: options.limit,
+            offset: options.offset,
+            source: source === 'all' ? undefined : source,
+            version: options.bundleVersion,
+        });
+        const nextOffset = resolveNextOffset(listedBundles.length, options);
+        if (options.json) {
+            printJson({ bundles: listedBundles, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No bundles.',
+            headers: [
+                'NUMBER',
+                'VERSION',
+                'SOURCE',
+                'STATUS',
+                'PLATFORMS',
+                'SIZE',
+                'CREATED',
+            ],
+            nextOffset,
+            rows: listedBundles.map(({ createdAt, number, platforms, sizeBytes, source, status, version, }) => [
+                number === null ? '' : `#${number}`,
+                version,
+                source,
+                status,
+                platforms.join(','),
+                resolveByteText(sizeBytes),
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/bundle/upload.js

@@ -0,0 +1,176 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveBundleLabel } from '../../utils/bundle-resolution.js';
+import { withTemporaryDirectory } from '../../utils/compressed-files.js';
+import { SigningKeyUnavailableError } from '../../utils/errors.js';
+import { readFingerprint } from '../../utils/fingerprint.js';
+import { detectFramework, resolveInputDirectoryPath, } from '../../utils/framework.js';
+import { resolveFrameworkModule } from '../../utils/frameworks/index.js';
+import { resolveGitProvenance } from '../../utils/git-provenance.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { readPackageJson } from '../../utils/package-json.js';
+import { createReporter, resolveByteText } from '../../utils/progress.js';
+import { locateProjectConfig } from '../../utils/project-config.js';
+import { promptText } from '../../utils/prompts.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+import { readSigningKeyPair } from '../../utils/signing-private-key.js';
+import { uploadBundle } from '../../utils/upload.js';
+const FINGERPRINT_UNKNOWN_TEXT = 'No binary of the app carries this fingerprint.';
+const PLATFORMS = ['android', 'ios'];
+// Validated in the schema, so a wrong platform is reported under the flag name.
+const platformListSchema = z
+    .string()
+    .transform(value => value.split(',').map(platform => platform.trim()))
+    .pipe(z.array(z.enum(PLATFORMS)).min(1));
+export const bundleUploadOptionShape = {
+    bundleVersion: z
+        .string()
+        .optional()
+        .describe("The bundle's version label; the project's package.json version by default."),
+    gitMessage: z
+        .string()
+        .optional()
+        .describe('The commit message subject to record, over the detected one.'),
+    gitRef: z
+        .string()
+        .optional()
+        .describe('The branch or tag to record, over the detected one.'),
+    gitSha: z
+        .string()
+        .optional()
+        .describe('The commit to record, over the detected one.'),
+    noGit: z
+        .boolean()
+        .optional()
+        .describe('Detect no git provenance; the typed --git-* flags still apply.'),
+    path: z
+        .string()
+        .optional()
+        .describe("The build to upload, the framework's build output by default: on React Native and Expo one platform's prepared bundle, Capacitor's webDir or Cordova's www."),
+    platform: platformListSchema
+        .optional()
+        .describe('The platforms the bundle serves, ios,android by default.'),
+    privateKeyPath: z
+        .string()
+        .optional()
+        .describe('The private key file to sign with, as signing-key create wrote it; HOTCODEPUSH_SIGNING_KEY holds its content in CI.'),
+};
+export default defineCommand({
+    description: 'Upload a build as a bundle, signed where a key is configured: only the files the app lacks move, then the full pack; nothing is released.',
+    examples: [
+        'hotcodepush bundle upload',
+        'hotcodepush bundle upload --path dist --bundle-version 1.4.2 --platform ios --json',
+    ],
+    options: defineCommandOptions(bundleUploadOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const uploadedBundles = await withTemporaryDirectory(async (packagingDirectoryPath) => {
+            const { bundleUploads } = await resolveUploadBundleOptions(hotCodePush, options, packagingDirectoryPath);
+            const bundles = [];
+            for (const uploadBundleOptions of bundleUploads) {
+                bundles.push(await uploadBundle(hotCodePush, uploadBundleOptions));
+            }
+            // All platform bundles share the project fingerprint, so one check covers them.
+            const [sharedOptions] = bundleUploads;
+            if (sharedOptions !== undefined &&
+                (await fetchIsFingerprintUnknown(hotCodePush, sharedOptions))) {
+                process.stderr.write(`Warning: ${FINGERPRINT_UNKNOWN_TEXT}\n`);
+            }
+            return bundles;
+        });
+        printUploadedBundles(uploadedBundles, options.json);
+    },
+});
+// An app without any binary stays silent, since its first store build is still to come.
+async function fetchIsFingerprintUnknown(hotCodePush, { appId, fingerprint }) {
+    const { count: fingerprintBinaryCount } = await hotCodePush.apps.binaries.count({ appId, fingerprint });
+    if (fingerprintBinaryCount > 0) {
+        return false;
+    }
+    const { count: binaryCount } = await hotCodePush.apps.binaries.count({
+        appId,
+    });
+    return binaryCount > 0;
+}
+// `--json` always prints an array, as `release create` prints its releases.
+function printUploadedBundles(uploadedBundles, isJson) {
+    if (isJson) {
+        printJson(uploadedBundles.map(resolveUploadedBundleJson));
+    }
+    else {
+        uploadedBundles.forEach(printUploadedBundle);
+    }
+}
+function resolveUploadedBundleJson({ bundle, upload }) {
+    return { ...bundle, upload };
+}
+function printUploadedBundle({ bundle, upload }) {
+    console.log(`Uploaded bundle ${resolveBundleLabel(bundle)} (${bundle.id}): ${upload.fileCount} files moved, ${resolveByteText(upload.sizeBytes)}.`);
+}
+// Nothing is uploaded here, so `release create` can resolve before it confirms.
+// Its dry run resolves without the private key.
+export async function resolveUploadBundleOptions(hotCodePush, options, packagingDirectoryPath, { isDryRun = false } = {}) {
+    const { directoryPath, projectConfig } = locateProjectConfig(options.config);
+    const framework = resolveFrameworkModule(detectFramework(directoryPath));
+    const appId = await fetchAppId(hotCodePush, options, projectConfig);
+    const sharedOptions = {
+        appId,
+        bundleVersion: await resolveBundleVersion(options, directoryPath),
+        fingerprint: await readFingerprint(directoryPath, projectConfig?.extraFingerprintPaths ?? []),
+        gitProvenance: await resolveGitProvenance(directoryPath, options),
+        nativeGluePaths: framework.nativeGluePaths,
+        reporter: createReporter(options),
+        signingPrivateKey: await readSigningPrivateKey(appId, projectConfig, options.privateKeyPath, isDryRun),
+    };
+    const packagedBundles = framework.packageBundles === undefined
+        ? [
+            {
+                directoryPath: await resolveInputDirectoryPath(options, '--path', directoryPath, framework),
+                platforms: options.platform ?? PLATFORMS,
+            },
+        ]
+        : await framework.packageBundles({
+            packagingDirectoryPath,
+            path: options.path,
+            platforms: options.platform,
+            projectDirectoryPath: directoryPath,
+        });
+    return {
+        appId,
+        bundleUploads: packagedBundles.map(packagedBundle => ({
+            ...sharedOptions,
+            ...packagedBundle,
+        })),
+    };
+}
+// Signing is off when `hotcodepush.json` lists no public key or names another app than `--app` meant.
+// A dry run signs nothing, so a given key is checked but none is required.
+async function readSigningPrivateKey(appId, projectConfig, privateKeyPath, isDryRun) {
+    const publicKeys = projectConfig?.appId === appId ? (projectConfig.publicKeys ?? []) : [];
+    try {
+        return ((await readSigningKeyPair(publicKeys, privateKeyPath))?.privateKey ?? null);
+    }
+    catch (error) {
+        if (isDryRun && error instanceof SigningKeyUnavailableError) {
+            return null;
+        }
+        throw error;
+    }
+}
+// The package.json version is the label a team already keeps.
+async function resolveBundleVersion(options, directoryPath) {
+    if (options.bundleVersion !== undefined) {
+        return options.bundleVersion;
+    }
+    if (existsSync(join(directoryPath, 'package.json'))) {
+        const { version } = readPackageJson(directoryPath);
+        if (version) {
+            return version;
+        }
+    }
+    return promptText('--bundle-version', 'Which version label does the bundle carry?', options);
+}

package/dist/commands/channel/create.js

@@ -0,0 +1,59 @@
+import { HotCodePushError } from '@hotcodepush/node';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { channelFieldsShape, resolveChannelFields, } from '../../utils/channel-fields.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { promptText } from '../../utils/prompts.js';
+import { fetchAppId, fetchChannels, resolveNamedResource, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Create a channel in an app, with an expiry for a preview channel and its auto-pause policy.',
+    examples: [
+        'hotcodepush channel create --name staging --protected',
+        'hotcodepush channel create --name pr-42 --expires-in 14d --if-not-exists --json',
+    ],
+    options: defineCommandOptions({
+        ...channelFieldsShape,
+        ifNotExists: z
+            .boolean()
+            .optional()
+            .describe('Return the channel of that name when it exists instead of failing, for re-run pipelines.'),
+        name: z
+            .string()
+            .optional()
+            .describe('The name: letters, digits, - and _, one to 64 characters, unique in the app.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const name = options.name ??
+            (await promptText('--name', 'What is the channel called?', options));
+        try {
+            const createdChannel = await hotCodePush.apps.channels.create({
+                ...resolveChannelFields(options),
+                appId,
+                name,
+            });
+            printChannel(createdChannel, 'Created channel', options.json);
+        }
+        catch (error) {
+            if (!options.ifNotExists || !isChannelNameTaken(error)) {
+                throw error;
+            }
+            printChannel(resolveNamedResource('channel', name, await fetchChannels(hotCodePush, appId)), 'Found the existing channel', options.json);
+        }
+    },
+});
+function isChannelNameTaken(error) {
+    return (error instanceof HotCodePushError && error.code === 'channel_name_taken');
+}
+function printChannel(channel, sentencePrefix, isJson) {
+    if (isJson) {
+        printJson(channel);
+    }
+    else {
+        console.log(`${sentencePrefix} ${channel.name} (${channel.id}).`);
+    }
+}

package/dist/commands/channel/delete.js

@@ -0,0 +1,68 @@
+import { HotCodePushError } from '@hotcodepush/node';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { UnknownNameError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { ID_SCHEMA } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Delete a channel and its releases; devices on it keep what they have.',
+    examples: [
+        'hotcodepush channel delete --channel staging',
+        'hotcodepush channel delete --channel pr-42 --ignore-not-found --yes --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ignoreNotFound: z
+            .boolean()
+            .optional()
+            .describe('Succeed when the channel does not exist, for re-run pipelines.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        try {
+            await deleteChannel(hotCodePush, options);
+        }
+        catch (error) {
+            if (!options.ignoreNotFound || !isChannelGone(error)) {
+                throw error;
+            }
+            if (options.json) {
+                printJson(resolveAbsentChannel(options.channel));
+            }
+            else {
+                console.log('The channel does not exist; nothing to delete.');
+            }
+        }
+    },
+});
+async function deleteChannel(hotCodePush, options) {
+    const fetchedChannel = await fetchChannel(hotCodePush, options);
+    const isConfirmed = await confirmConsequence(`deletes channel ${fetchedChannel.name} and its releases: devices on it keep what they have`, options);
+    if (!isConfirmed) {
+        return;
+    }
+    await hotCodePush.apps.channels.delete({
+        appId: fetchedChannel.appId,
+        channelId: fetchedChannel.id,
+    });
+    if (options.json) {
+        printJson({ id: fetchedChannel.id, name: fetchedChannel.name });
+    }
+    else {
+        console.log(`Deleted channel ${fetchedChannel.name} (${fetchedChannel.id}).`);
+    }
+}
+// A deleted app has no channels either.
+function isChannelGone(error) {
+    return (error instanceof UnknownNameError ||
+        (error instanceof HotCodePushError && error.code === 'not_found'));
+}
+function resolveAbsentChannel(channel) {
+    return channel !== undefined && ID_SCHEMA.safeParse(channel).success
+        ? { id: channel, name: null }
+        : { id: null, name: channel ?? null };
+}

package/dist/commands/channel/get.js

@@ -0,0 +1,45 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveEffectiveFailurePolicy, resolveFailurePolicyDetails, } from '../../utils/channel-fields.js';
+import { resolveReleaseDeviceCount } from '../../utils/fleet.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Print a channel with its device counts, hotcodepush.json's by default.",
+    examples: [
+        'hotcodepush channel get',
+        'hotcodepush channel get --channel staging --json',
+    ],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        if (options.json) {
+            printJson(fetchedChannel);
+            return;
+        }
+        const fleet = await hotCodePush.apps.statistics.fleet.get({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        printDetails([
+            ['ID', fetchedChannel.id],
+            ['Name', fetchedChannel.name],
+            [
+                'Status',
+                fetchedChannel.pausedAt === null
+                    ? 'running'
+                    : `paused since ${fetchedChannel.pausedAt}`,
+            ],
+            ['Protected', fetchedChannel.isProtected ? 'yes' : 'no'],
+            ['Discoverable', fetchedChannel.isDiscoverable ? 'yes' : 'no'],
+            ['Expires', fetchedChannel.expiresAt ?? 'never'],
+            ...resolveFailurePolicyDetails(resolveEffectiveFailurePolicy(fetchedChannel)),
+            ['Active devices', String(fleet.deviceCount)],
+            ['Current devices', String(fleet.currentDeviceCount)],
+            ['Embedded devices', String(resolveReleaseDeviceCount(fleet, null))],
+            ['Created', fetchedChannel.createdAt],
+        ]);
+    },
+});

package/dist/commands/channel/list.js

@@ -0,0 +1,39 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable, resolveDate } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List an app's channels, newest first.",
+    examples: [
+        'hotcodepush channel list',
+        'hotcodepush channel list --app "My App" --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedChannels = await hotCodePush.apps.channels.list({
+            appId: await fetchAppId(hotCodePush, options, readProjectConfig(options.config)),
+            limit: options.limit,
+            offset: options.offset,
+        });
+        const nextOffset = resolveNextOffset(listedChannels.length, options);
+        if (options.json) {
+            printJson({ channels: listedChannels, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No channels.',
+            headers: ['ID', 'NAME', 'STATUS', 'CREATED'],
+            nextOffset,
+            rows: listedChannels.map(({ createdAt, id, name, pausedAt }) => [
+                id,
+                name,
+                pausedAt === null ? 'running' : 'paused',
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});