hotcodepush 0.0.1 → 0.2.0

package/dist/commands/channel/list.js

@@ -0,0 +1,39 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.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),
+            ]),
+        });
+    },
+});

package/dist/commands/channel/pause.js

@@ -0,0 +1,32 @@
+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 { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Pause a channel, the kill switch: it serves nothing new until resumed.',
+    examples: [
+        'hotcodepush channel pause --channel production',
+        'hotcodepush channel pause --channel production --yes --json',
+    ],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`pauses channel ${fetchedChannel.name}: devices keep what they have and get nothing new`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const pausedChannel = await hotCodePush.apps.channels.pause({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        if (options.json) {
+            printJson(pausedChannel);
+        }
+        else {
+            console.log(`Paused channel ${pausedChannel.name} (${pausedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/channel/resume.js

@@ -0,0 +1,32 @@
+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 { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Resume a paused channel: it serves its releases again.',
+    examples: [
+        'hotcodepush channel resume --channel production',
+        'hotcodepush channel resume --channel production --yes --json',
+    ],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`resumes channel ${fetchedChannel.name}: devices receive its releases again`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const resumedChannel = await hotCodePush.apps.channels.resume({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        if (options.json) {
+            printJson(resumedChannel);
+        }
+        else {
+            console.log(`Resumed channel ${resumedChannel.name} (${resumedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/channel/update.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { channelFieldsClearShape, channelFieldsShape, resolveChannelFields, } from '../../utils/channel-fields.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Rename a channel or change its flags, expiry and auto-pause policy.',
+    examples: [
+        'hotcodepush channel update --channel staging --protected',
+        'hotcodepush channel update --channel pr-42 --expires-in 7d --json',
+    ],
+    options: defineCommandOptions({
+        ...channelFieldsClearShape,
+        ...channelFieldsShape,
+        ...channelOptionShape,
+        name: z
+            .string()
+            .optional()
+            .describe("The channel's new name: letters, digits, - and _, one to 64 characters."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const channelFields = resolveChannelFields(options);
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const updatedChannel = await hotCodePush.apps.channels.update({
+            ...channelFields,
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+            name: options.name,
+        });
+        if (options.json) {
+            printJson(updatedChannel);
+        }
+        else {
+            console.log(`Updated channel ${updatedChannel.name} (${updatedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/checkout/create.js

@@ -0,0 +1,25 @@
+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 { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Enable billing on a free organization: create the checkout for pay-as-you-go and print its URL to open.',
+    examples: [
+        'hotcodepush checkout create',
+        'hotcodepush checkout create --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const createdCheckout = await hotCodePush.organizations.checkouts.create({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(createdCheckout);
+        }
+        else {
+            console.log(`Open the checkout to enable billing: ${createdCheckout.url}`);
+        }
+    },
+});

package/dist/commands/completion.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { defineCommand } from '../utils/command.js';
+import { COMPLETION_SHELLS, readCompletionScript, } from '../utils/completion/script-files.js';
+import { InvalidParameterError } from '../utils/errors.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson } from '../utils/output.js';
+import { promptSelect } from '../utils/prompts.js';
+// zodline reports an invalid argument as a plain error that would read as `unexpected`.
+// So the action checks the shell itself.
+const ShellSchema = z.enum(COMPLETION_SHELLS);
+export default defineCommand({
+    description: 'Print the completion script for <shell>, bash, fish or zsh: eval "$(hotcodepush completion <shell>)" loads it from ~/.bashrc, or from ~/.zshrc after compinit, and fish loads it saved as ~/.config/fish/completions/hotcodepush.fish.',
+    authentication: 'optional',
+    examples: [
+        'eval "$(hotcodepush completion zsh)"',
+        'hotcodepush completion fish > ~/.config/fish/completions/hotcodepush.fish',
+    ],
+    args: z.array(z.string()),
+    options: defineCommandOptions({}),
+    action: async (options, args) => {
+        if (args.length > 1) {
+            throw new InvalidParameterError(`The completion command takes one shell, <shell>. It does not take ${args.slice(1).join(' ')}.`);
+        }
+        const shell = args[0] ??
+            (await promptSelect('<shell>', 'Which shell is the completion script for?', ShellSchema.options.map(value => ({ label: value, value })), options));
+        const parsedShell = ShellSchema.safeParse(shell);
+        if (!parsedShell.success) {
+            throw new InvalidParameterError(`The shell ${shell} has no completion script.`, 'Pass bash, fish or zsh as <shell>.');
+        }
+        const script = await readCompletionScript(parsedShell.data);
+        if (options.json) {
+            printJson({ script });
+            return;
+        }
+        console.log(script);
+    },
+});

package/dist/commands/customer-portal-session/create.js

@@ -0,0 +1,25 @@
+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 { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Create a session of the customer portal for an organization's invoices and payment method, and print its URL to open.",
+    examples: [
+        'hotcodepush customer-portal-session create',
+        'hotcodepush customer-portal-session create --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const createdSession = await hotCodePush.organizations.customerPortalSessions.create({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(createdSession);
+        }
+        else {
+            console.log(`Open the customer portal for the invoices and the payment method: ${createdSession.url}`);
+        }
+    },
+});

package/dist/commands/device/delete.js

@@ -0,0 +1,29 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { deviceOptionShape, resolveDeviceReference, } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+export default defineCommand({
+    description: "Delete a device's record, an erasure request. The device reports again with its next check.",
+    examples: [
+        'hotcodepush device delete --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259',
+        'hotcodepush device delete --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --yes --json',
+    ],
+    options: defineCommandOptions(deviceOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const { appId, deviceId } = await resolveDeviceReference(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`deletes device ${deviceId}'s record for good, the erasure request. The device reports again with its next check`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.apps.devices.delete({ appId, deviceId });
+        if (options.json) {
+            printJson({ id: deviceId, name: null });
+        }
+        else {
+            console.log(`Deleted device ${deviceId}.`);
+        }
+    },
+});

package/dist/commands/device/get.js

@@ -0,0 +1,60 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { deviceOptionShape, resolveDeviceReference, } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson, printTable, resolveDate, } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { resolveBinaryText } from './list.js';
+export default defineCommand({
+    description: 'Print what a device runs and reported last, with its outcome per release, newest first.',
+    examples: [
+        'hotcodepush device get --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259',
+        'hotcodepush device get --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --json',
+    ],
+    options: defineCommandOptions(deviceOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const deviceReference = await resolveDeviceReference(hotCodePush, options);
+        const fetchedDevice = await hotCodePush.apps.devices.get({
+            ...deviceReference,
+            relations: ['channel'],
+        });
+        const fetchedEvents = await fetchAllPages(page => hotCodePush.apps.devices.events.list({ ...deviceReference, ...page }));
+        if (options.json) {
+            printJson({ ...fetchedDevice, events: fetchedEvents });
+            return;
+        }
+        printDetails([
+            ['ID', fetchedDevice.deviceId],
+            ['Platform', `${fetchedDevice.platform} ${fetchedDevice.osVersion}`],
+            ['Binary', resolveBinaryText(fetchedDevice)],
+            ['Fingerprint', fetchedDevice.fingerprint ?? 'none'],
+            [
+                'Channel',
+                `${fetchedDevice.channel?.name ?? fetchedDevice.channelId ?? 'none'} (${fetchedDevice.channelSource})`,
+            ],
+            ['Release', fetchedDevice.currentReleaseId ?? 'the embedded bundle'],
+            ['SDK', fetchedDevice.sdkVersion],
+            [
+                'Attributes',
+                Object.entries(fetchedDevice.attributes)
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join(', ') || 'none',
+            ],
+            ['Country', fetchedDevice.country ?? 'unknown'],
+            ['Last seen', fetchedDevice.lastSeenAt],
+            ['First seen', fetchedDevice.createdAt],
+        ]);
+        printTable({
+            emptyText: 'No outcomes yet: the device has not checked a release.',
+            headers: ['RELEASE', 'OUTCOME', 'REASON', 'DATE'],
+            nextOffset: null,
+            rows: fetchedEvents.map(({ createdAt, reason, releaseId, type }) => [
+                releaseId,
+                type,
+                reason ?? '',
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/device/list.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { resolveTimeBound } from '../../utils/duration.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, fetchChannels, fetchResourceId, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List the app's devices, the newest report first, filtered by what they reported. It is for support and QA, never for a pipeline.",
+    examples: [
+        'hotcodepush device list --attribute userId=42',
+        'hotcodepush device list --platform ios --binary-version 2.4.1 --last-seen-since 2026-09-01T00:00:00Z --json',
+    ],
+    options: defineCommandOptions({
+        ...paginationShape,
+        attribute: z
+            .string()
+            .optional()
+            .describe('An attribute the app set, key=value, such as userId=42.'),
+        binaryBuild: z
+            .string()
+            .optional()
+            .describe('The build number the devices run.'),
+        binaryVersion: z
+            .string()
+            .optional()
+            .describe('The app version the devices run.'),
+        channel: z
+            .string()
+            .optional()
+            .describe('The channel the devices follow, by id or name.'),
+        fingerprint: z
+            .string()
+            .optional()
+            .describe('The native fingerprint the devices report.'),
+        lastSeenSince: z
+            .string()
+            .optional()
+            .describe('The earliest last report, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        lastSeenUntil: z
+            .string()
+            .optional()
+            .describe('The latest last report, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        platform: z
+            .enum(['android', 'ios'])
+            .optional()
+            .describe('The platform, ios or android.'),
+        sdkVersion: z
+            .string()
+            .optional()
+            .describe('The SDK version the devices run.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const listedDevices = await hotCodePush.apps.devices.list({
+            appId,
+            attribute: options.attribute,
+            binaryBuild: options.binaryBuild,
+            binaryVersion: options.binaryVersion,
+            channelId: options.channel === undefined
+                ? undefined
+                : await fetchResourceId('channel', options.channel, () => fetchChannels(hotCodePush, appId)),
+            fingerprint: options.fingerprint,
+            lastSeenSince: resolveTimeBound(options.lastSeenSince),
+            lastSeenUntil: resolveTimeBound(options.lastSeenUntil),
+            limit: options.limit,
+            offset: options.offset,
+            platform: options.platform,
+            relations: ['channel'],
+            sdkVersion: options.sdkVersion,
+        });
+        const nextOffset = resolveNextOffset(listedDevices.length, options);
+        if (options.json) {
+            printJson({ devices: listedDevices, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No devices match. A device appears with its first check.',
+            headers: ['ID', 'PLATFORM', 'BINARY', 'CHANNEL', 'SDK', 'LAST SEEN'],
+            nextOffset,
+            rows: listedDevices.map(device => [
+                device.deviceId,
+                device.platform,
+                resolveBinaryText(device),
+                device.channel?.name ?? device.channelId ?? 'none',
+                device.sdkVersion,
+                resolveDate(device.lastSeenAt),
+            ]),
+        });
+    },
+});
+export function resolveBinaryText({ binaryBuild, binaryVersion, }) {
+    return `${binaryVersion} (${binaryBuild})`;
+}