hotcodepush 0.0.1 → 0.2.0

package/dist/commands/usage/get.js

@@ -0,0 +1,31 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { resolveByteText } from '../../utils/progress.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { monthOptionShape, resolveMonthText } from '../../utils/usage-month.js';
+export default defineCommand({
+    description: "Print an organization's monthly active devices and data transfer in a month, the totals the invoice counts.",
+    examples: [
+        'hotcodepush usage get',
+        'hotcodepush usage get --organization Acme --month 2026-09 --json',
+    ],
+    options: defineCommandOptions(monthOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedUsage = await hotCodePush.organizations.usage.get({
+            month: options.month,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(fetchedUsage);
+            return;
+        }
+        printDetails([
+            ['Month', resolveMonthText(fetchedUsage.month)],
+            ['MAU', String(fetchedUsage.monthlyActiveDeviceCount)],
+            ['Data transfer', resolveByteText(fetchedUsage.dataTransferBytes)],
+        ]);
+    },
+});

package/dist/commands/usage/list.js

@@ -0,0 +1,41 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { resolveByteText } from '../../utils/progress.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { monthOptionShape } from '../../utils/usage-month.js';
+export default defineCommand({
+    description: "List an organization's apps with their monthly active devices and data transfer in a month, the most devices first.",
+    examples: [
+        'hotcodepush usage list --month 2026-09',
+        'hotcodepush usage list --organization Acme --limit 10 --offset 10 --json',
+    ],
+    options: defineCommandOptions({ ...monthOptionShape, ...paginationShape }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedApps = await hotCodePush.organizations.usage.apps.list({
+            limit: options.limit,
+            month: options.month,
+            offset: options.offset,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+            relations: ['app'],
+        });
+        const nextOffset = resolveNextOffset(listedApps.length, options);
+        if (options.json) {
+            printJson({ apps: listedApps, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No app had monthly active devices in the month.',
+            headers: ['APP', 'MAU', 'DATA TRANSFER'],
+            nextOffset,
+            rows: listedApps.map(({ app, appId, dataTransferBytes, monthlyActiveDeviceCount }) => [
+                app?.name ?? appId,
+                String(monthlyActiveDeviceCount),
+                resolveByteText(dataTransferBytes),
+            ]),
+        });
+    },
+});

package/dist/commands/webhook/create.js

@@ -0,0 +1,72 @@
+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 { promptSelect, promptText } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { fetchWebhookAppId, resolveWebhookEventTypes, webhookAppOptionShape, webhookEventOptionShape, } from '../../utils/webhook-resolution.js';
+const WEBHOOK_FORMATS = ['raw', 'slack', 'discord', 'teams'];
+export default defineCommand({
+    description: "Create a webhook that posts the organization's events to a URL, as signed JSON or as a Slack, Discord or Teams message. A raw webhook's secret is printed this once.",
+    examples: [
+        'hotcodepush webhook create --name releases --url https://example.com/hooks/hotcodepush --format raw --event release.created --event release.paused',
+        'hotcodepush webhook create --name team-chat --url https://chat.example.com/incoming/team --format slack --event release.failure_rate_exceeded --app "My App" --json',
+    ],
+    options: defineCommandOptions({
+        ...webhookAppOptionShape,
+        ...webhookEventOptionShape,
+        format: z
+            .enum(WEBHOOK_FORMATS)
+            .optional()
+            .describe("raw for HotCodePush's signed JSON, slack, discord or teams for a message to that service's incoming-webhook URL."),
+        name: z
+            .string()
+            .optional()
+            .describe('The name, unique in the organization.'),
+        url: z
+            .string()
+            .optional()
+            .describe('The https URL the events are posted to.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const name = options.name ??
+            (await promptText('--name', 'What is the webhook called?', options));
+        const url = options.url ??
+            (await promptText('--url', 'Which URL receives the events?', options));
+        const format = options.format ?? (await promptFormat(options));
+        const events = options.event?.length
+            ? options.event
+            : [
+                await promptText('--event', 'Which event type, such as release.created?', options),
+            ];
+        const createdWebhook = await hotCodePush.organizations.webhooks.create({
+            appId: options.app === undefined
+                ? undefined
+                : await fetchWebhookAppId(hotCodePush, organizationId, options.app),
+            events: resolveWebhookEventTypes(events),
+            format,
+            name,
+            organizationId,
+            url,
+        });
+        if (options.json) {
+            printJson(createdWebhook);
+            return;
+        }
+        printCreatedWebhook(createdWebhook);
+    },
+});
+function printCreatedWebhook(webhook) {
+    console.log(`Created webhook ${webhook.name} (${webhook.id}).`);
+    if (webhook.secret === null) {
+        return;
+    }
+    console.log(`Secret: ${webhook.secret}`);
+    console.log('Store the secret now to verify the signature of every delivery. It is never shown again.');
+}
+function promptFormat(options) {
+    return promptSelect('--format', 'Which format?', WEBHOOK_FORMATS.map(format => ({ label: format, value: format })), options);
+}

package/dist/commands/webhook/delete.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 { fetchWebhook, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+export default defineCommand({
+    description: 'Delete a webhook and its delivery log.',
+    examples: [
+        'hotcodepush webhook delete --webhook releases',
+        'hotcodepush webhook delete --webhook team-chat --yes --json',
+    ],
+    options: defineCommandOptions(webhookOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedWebhook = await fetchWebhook(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`deletes webhook ${fetchedWebhook.name} and its delivery log: ${fetchedWebhook.url} receives no more events`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.organizations.webhooks.delete({
+            organizationId: fetchedWebhook.organizationId,
+            webhookId: fetchedWebhook.id,
+        });
+        if (options.json) {
+            printJson({ id: fetchedWebhook.id, name: fetchedWebhook.name });
+        }
+        else {
+            console.log(`Deleted webhook ${fetchedWebhook.name} (${fetchedWebhook.id}).`);
+        }
+    },
+});

package/dist/commands/webhook/get.js

@@ -0,0 +1,34 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { fetchWebhook, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+export default defineCommand({
+    description: 'Print a webhook: its URL, format, events, app filter and whether it is enabled. The secret is never printed.',
+    examples: [
+        'hotcodepush webhook get --webhook releases',
+        'hotcodepush webhook get --webhook 3c9e7a52-8d14-4b6f-a0e2-5f71c3d8b946 --json',
+    ],
+    options: defineCommandOptions(webhookOptionShape),
+    action: async (options) => {
+        const fetchedWebhook = await fetchWebhook(createApiClient(), options);
+        if (options.json) {
+            printJson(fetchedWebhook);
+            return;
+        }
+        printWebhookDetails(fetchedWebhook);
+    },
+});
+function printWebhookDetails(webhook) {
+    printDetails([
+        ['ID', webhook.id],
+        ['Name', webhook.name],
+        ['URL', webhook.url],
+        ['Format', webhook.format],
+        ['Events', webhook.events.join(', ')],
+        ['App', webhook.appId ?? 'every app'],
+        ['Enabled', webhook.isEnabled ? 'yes' : 'no'],
+        ['Consecutive failures', String(webhook.consecutiveFailureCount)],
+        ['Created', webhook.createdAt],
+    ]);
+}

package/dist/commands/webhook/list.js

@@ -0,0 +1,40 @@
+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 { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List an organization's webhooks, newest first.",
+    examples: [
+        'hotcodepush webhook list',
+        'hotcodepush webhook list --organization Acme --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedWebhooks = await hotCodePush.organizations.webhooks.list({
+            limit: options.limit,
+            offset: options.offset,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        const nextOffset = resolveNextOffset(listedWebhooks.length, options);
+        if (options.json) {
+            printJson({ nextOffset, webhooks: listedWebhooks });
+            return;
+        }
+        printTable({
+            emptyText: 'No webhooks.',
+            headers: ['ID', 'NAME', 'FORMAT', 'URL', 'ENABLED', 'CREATED'],
+            nextOffset,
+            rows: listedWebhooks.map(({ createdAt, format, id, isEnabled, name, url }) => [
+                id,
+                name,
+                format,
+                url,
+                isEnabled ? 'yes' : 'no',
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/webhook/test.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 { fetchWebhook, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+import { printSettledDelivery } from '../webhook-delivery/redeliver.js';
+export default defineCommand({
+    description: "Send one sample event, webhook.test, to a webhook's URL and print the receiver's answer.",
+    examples: [
+        'hotcodepush webhook test --webhook releases',
+        'hotcodepush webhook test --webhook team-chat --yes --json',
+    ],
+    options: defineCommandOptions(webhookOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedWebhook = await fetchWebhook(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`sends a sample event to ${fetchedWebhook.url}`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const settledDelivery = await hotCodePush.organizations.webhooks.test({
+            organizationId: fetchedWebhook.organizationId,
+            webhookId: fetchedWebhook.id,
+        });
+        if (options.json) {
+            printJson(settledDelivery);
+            return;
+        }
+        printSettledDelivery(settledDelivery, fetchedWebhook.name);
+    },
+});

package/dist/commands/webhook/update.js

@@ -0,0 +1,56 @@
+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 { defineCommandOptions } from '../../utils/global-options.js';
+import { resolveNullableField } from '../../utils/nullable-field.js';
+import { printJson } from '../../utils/output.js';
+import { fetchWebhook, fetchWebhookAppId, resolveWebhookEventTypes, webhookAppOptionShape, webhookEventOptionShape, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+export default defineCommand({
+    description: 'Rename a webhook or change its URL, events, app filter or whether it is enabled. The format and the secret never change.',
+    examples: [
+        'hotcodepush webhook update --webhook releases --event release.created --event release.revoked',
+        'hotcodepush webhook update --webhook team-chat --enabled --clear-app --json',
+    ],
+    options: defineCommandOptions({
+        ...webhookAppOptionShape,
+        ...webhookEventOptionShape,
+        ...webhookOptionShape,
+        clearApp: z
+            .boolean()
+            .optional()
+            .describe("Sets the app filter back to null: the webhook receives every app's events and the organization's."),
+        enabled: booleanFlagSchema
+            .optional()
+            .describe('Whether the webhook delivers. Turning it on again restarts the count of failures that disables it. Pass false to turn it off.'),
+        name: z.string().optional().describe("The webhook's new name."),
+        url: z
+            .string()
+            .optional()
+            .describe('The https URL the events are posted to.'),
+    }),
+    action: async (options) => {
+        const app = resolveNullableField(options.app, options.clearApp, 'app');
+        const hotCodePush = createApiClient();
+        const fetchedWebhook = await fetchWebhook(hotCodePush, options);
+        const updatedWebhook = await hotCodePush.organizations.webhooks.update({
+            appId: typeof app === 'string'
+                ? await fetchWebhookAppId(hotCodePush, fetchedWebhook.organizationId, app)
+                : app,
+            events: options.event === undefined
+                ? undefined
+                : resolveWebhookEventTypes(options.event),
+            isEnabled: options.enabled,
+            name: options.name,
+            organizationId: fetchedWebhook.organizationId,
+            url: options.url,
+            webhookId: fetchedWebhook.id,
+        });
+        if (options.json) {
+            printJson(updatedWebhook);
+        }
+        else {
+            console.log(`Updated webhook ${updatedWebhook.name} (${updatedWebhook.id}).`);
+        }
+    },
+});

package/dist/commands/webhook-delivery/list.js

@@ -0,0 +1,63 @@
+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 } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { fetchWebhook, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+import { resolveResponseText } from './redeliver.js';
+export default defineCommand({
+    description: "List a webhook's deliveries, newest first, filtered by status and time, to find the ones worth redelivering. Each is kept for 30 days.",
+    examples: [
+        'hotcodepush webhook-delivery list --webhook releases --status failed --created-since 2h',
+        'hotcodepush webhook-delivery list --webhook releases --json',
+    ],
+    options: defineCommandOptions({
+        ...paginationShape,
+        ...webhookOptionShape,
+        createdSince: z
+            .string()
+            .optional()
+            .describe('The earliest delivery, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        createdUntil: z
+            .string()
+            .optional()
+            .describe('The latest delivery, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        status: z
+            .enum(['failed', 'pending', 'succeeded'])
+            .optional()
+            .describe('failed, pending while it is retried, or succeeded.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedWebhook = await fetchWebhook(hotCodePush, options);
+        const listedDeliveries = await hotCodePush.organizations.webhooks.deliveries.list({
+            createdSince: resolveTimeBound(options.createdSince),
+            createdUntil: resolveTimeBound(options.createdUntil),
+            limit: options.limit,
+            offset: options.offset,
+            organizationId: fetchedWebhook.organizationId,
+            status: options.status,
+            webhookId: fetchedWebhook.id,
+        });
+        const nextOffset = resolveNextOffset(listedDeliveries.length, options);
+        if (options.json) {
+            printJson({ nextOffset, webhookDeliveries: listedDeliveries });
+            return;
+        }
+        printTable({
+            emptyText: 'No deliveries match.',
+            headers: ['ID', 'TIME', 'TYPE', 'STATUS', 'RESPONSE', 'ATTEMPTS'],
+            nextOffset,
+            rows: listedDeliveries.map(delivery => [
+                delivery.id,
+                delivery.createdAt,
+                delivery.type,
+                delivery.status,
+                resolveResponseText(delivery),
+                String(delivery.attemptCount),
+            ]),
+        });
+    },
+});

package/dist/commands/webhook-delivery/redeliver.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence, promptText } from '../../utils/prompts.js';
+import { fetchWebhook, webhookOptionShape, } from '../../utils/webhook-resolution.js';
+export default defineCommand({
+    description: "Deliver a webhook's event again, once, and print the receiver's answer. A pending delivery is taken from the retries.",
+    examples: [
+        'hotcodepush webhook-delivery redeliver --webhook releases --delivery 9a4f2e71-3b8c-4d65-b1e7-0c2d5f8a6e93',
+        'hotcodepush webhook-delivery redeliver --webhook releases --delivery 9a4f2e71-3b8c-4d65-b1e7-0c2d5f8a6e93 --yes --json',
+    ],
+    options: defineCommandOptions({
+        ...webhookOptionShape,
+        delivery: z
+            .string()
+            .optional()
+            .describe('The delivery, by id, as "hotcodepush webhook-delivery list" prints it.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedWebhook = await fetchWebhook(hotCodePush, options);
+        // A delivery has no name to pick from, so a missing one is asked for as text.
+        const deliveryId = options.delivery ??
+            (await promptText('--delivery', 'Which delivery id?', options));
+        const isConfirmed = await confirmConsequence(`sends the event of delivery ${deliveryId} to ${fetchedWebhook.url} again`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const settledDelivery = await hotCodePush.organizations.webhooks.deliveries.redeliver({
+            deliveryId,
+            organizationId: fetchedWebhook.organizationId,
+            webhookId: fetchedWebhook.id,
+        });
+        if (options.json) {
+            printJson(settledDelivery);
+            return;
+        }
+        printSettledDelivery(settledDelivery, fetchedWebhook.name);
+    },
+});
+export function printSettledDelivery(delivery, webhookName) {
+    console.log(`Sent ${delivery.type} to webhook ${webhookName}: ${delivery.status}, ${resolveResponseText(delivery)}.`);
+}
+export function resolveResponseText({ responseCode }) {
+    return responseCode === null ? 'no response' : `HTTP ${responseCode}`;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,24 @@
+import { DEFAULT_API_URL } from '../config/consts.js';
+import { defineCommand } from '../utils/command.js';
+import { fetchCurrentUser, resolveCredentialText, } from '../utils/credential.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson } from '../utils/output.js';
+import { isEnvironmentToken } from '../utils/token-store.js';
+import { readApiUrl } from '../utils/user-config.js';
+export default defineCommand({
+    description: 'Print the user you are logged in as, or the one HOTCODEPUSH_TOKEN stands for.',
+    examples: ['hotcodepush whoami', 'hotcodepush whoami --json'],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const user = await fetchCurrentUser();
+        const apiUrl = readApiUrl();
+        if (options.json) {
+            printJson({ apiUrl, user });
+            return;
+        }
+        console.log(resolveCredentialText(user, isEnvironmentToken()));
+        if (apiUrl !== DEFAULT_API_URL) {
+            console.log(`API: ${apiUrl}`);
+        }
+    },
+});