hotcodepush 0.0.1 → 0.2.0

package/dist/commands/invitation/accept.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { isInteractive } from '../../utils/environment.js';
+import { MissingParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { promptSelect, promptText } from '../../utils/prompts.js';
+export default defineCommand({
+    description: 'Accept an invitation to an organization with the token from its mail.',
+    examples: [
+        'hotcodepush invitation accept',
+        'hotcodepush invitation accept --invitation 4c8e2a6f-1d3b-4e97-a5c0-8f2d6b4a1e93 --token p8Xc2LmQ4rTzN7vB --json',
+    ],
+    options: defineCommandOptions({
+        invitation: z
+            .string()
+            .optional()
+            .describe('The invitation, by the id its mail carries.'),
+        token: z
+            .string()
+            .optional()
+            .describe('The token the invitation mail carries.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const invitationId = options.invitation ?? (await promptInvitationId(hotCodePush, options));
+        const token = options.token ??
+            (await promptText('--token', 'What is the token from the invitation mail?', options));
+        const acceptedMember = await hotCodePush.invitations.accept({
+            invitationId,
+            token,
+        });
+        if (options.json) {
+            printJson(acceptedMember);
+        }
+        else {
+            console.log(`Joined organization ${acceptedMember.organizationId} with role ${acceptedMember.role}.`);
+        }
+    },
+});
+async function promptInvitationId(hotCodePush, options) {
+    if (!isInteractive(options)) {
+        throw new MissingParameterError('--invitation');
+    }
+    const fetchedInvitations = await hotCodePush.invitations.list({
+        relations: ['organization'],
+    });
+    return promptSelect('--invitation', 'Which invitation?', fetchedInvitations.map(({ id, organization, organizationId, role }) => ({
+        label: `${organization?.name ?? organizationId} with role ${role}`,
+        value: id,
+    })), options);
+}

package/dist/commands/invitation/create.js

@@ -0,0 +1,52 @@
+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, promptSelect, promptText, } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+const INVITATION_ROLES = [
+    'admin',
+    'billing',
+    'member',
+];
+export default defineCommand({
+    description: 'Invite an address to the organization with a role. The invitation mail is valid for two days.',
+    examples: [
+        'hotcodepush invitation create --email anna@example.com --role member',
+        'hotcodepush invitation create --organization Acme --email anna@example.com --role admin --yes --json',
+    ],
+    options: defineCommandOptions({
+        email: z.string().optional().describe('The address to invite.'),
+        role: z
+            .enum(INVITATION_ROLES)
+            .optional()
+            .describe('The role the invitee gets: admin, billing or member.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const email = options.email ??
+            (await promptText('--email', 'Which address do you invite?', options));
+        const role = options.role ??
+            (await promptSelect('--role', 'Which role does the invitee get?', INVITATION_ROLES.map(role => ({ label: role, value: role })), options));
+        const fetchedOrganization = await hotCodePush.organizations.get({
+            organizationId,
+        });
+        const isConfirmed = await confirmConsequence(`invites ${email} to organization ${fetchedOrganization.name} with role ${role}`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const createdInvitation = await hotCodePush.organizations.invitations.create({
+            email,
+            organizationId,
+            role,
+        });
+        if (options.json) {
+            printJson(createdInvitation);
+        }
+        else {
+            console.log(`Invited ${createdInvitation.email} (${createdInvitation.id}) to organization ${fetchedOrganization.name} with role ${createdInvitation.role}.`);
+        }
+    },
+});

package/dist/commands/invitation/delete.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { InvalidParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { confirmConsequence, promptSelect } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Withdraw a pending invitation. The link in its mail stops working at once.',
+    examples: [
+        'hotcodepush invitation delete --invitation anna@example.com',
+        'hotcodepush invitation delete --invitation 4c8e2a6f-1d3b-4e97-a5c0-8f2d6b4a1e93 --yes --json',
+    ],
+    options: defineCommandOptions({
+        invitation: z
+            .string()
+            .optional()
+            .describe('The pending invitation, by id or email.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        // Invitations have no read by id, and only a pending one is unique by its email.
+        const pendingInvitations = await fetchAllPages(page => hotCodePush.organizations.invitations.list({
+            organizationId,
+            status: 'pending',
+            ...page,
+        }));
+        const invitation = resolveInvitation(pendingInvitations, options.invitation ??
+            (await promptSelect('--invitation', 'Which invitation?', pendingInvitations.map(({ email, id }) => ({
+                label: email,
+                value: id,
+            })), options)));
+        const isConfirmed = await confirmConsequence(`withdraws the invitation to ${invitation.email}: the link in its mail stops working`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.organizations.invitations.delete({
+            invitationId: invitation.id,
+            organizationId,
+        });
+        if (options.json) {
+            printJson({ id: invitation.id, name: invitation.email });
+        }
+        else {
+            console.log(`Withdrew the invitation to ${invitation.email} (${invitation.id}).`);
+        }
+    },
+});
+// The API stores emails lowercased.
+function resolveInvitation(invitations, reference) {
+    const lowercasedReference = reference.toLowerCase();
+    const invitation = invitations.find(({ email, id }) => id === reference || email.toLowerCase() === lowercasedReference);
+    if (invitation === undefined) {
+        throw new InvalidParameterError(`The organization has no pending invitation ${reference} from --invitation.`, 'Run "hotcodepush invitation list" for the ids and emails.');
+    }
+    return invitation;
+}

package/dist/commands/invitation/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 the organization's pending invitations, the ones a link can still accept, newest first.",
+    examples: [
+        'hotcodepush invitation list --organization Acme',
+        'hotcodepush invitation list --limit 10 --offset 10 --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedInvitations = await hotCodePush.organizations.invitations.list({
+            limit: options.limit,
+            offset: options.offset,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+            status: 'pending',
+        });
+        const nextOffset = resolveNextOffset(listedInvitations.length, options);
+        if (options.json) {
+            printJson({ invitations: listedInvitations, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No pending invitations.',
+            headers: ['ID', 'EMAIL', 'ROLE', 'EXPIRES', 'CREATED'],
+            nextOffset,
+            rows: listedInvitations.map(({ createdAt, email, expiresAt, id, role }) => [
+                id,
+                email,
+                role,
+                resolveDate(expiresAt),
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/limit/list.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 { printJson, printTable } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List the limits in effect for an organization: each value, the plan's default and whether it is overridden.",
+    examples: [
+        'hotcodepush limit list',
+        'hotcodepush limit list --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedLimits = await hotCodePush.organizations.limits.get({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(fetchedLimits);
+            return;
+        }
+        printTable({
+            emptyText: 'No limits.',
+            headers: ['LIMIT', 'VALUE', 'DEFAULT', 'OVERRIDDEN'],
+            nextOffset: null,
+            rows: Object.entries(fetchedLimits).map(([key, limit]) => [
+                key,
+                String(limit.value),
+                String(limit.default),
+                limit.isOverridden ? 'yes' : 'no',
+            ]),
+        });
+    },
+});

package/dist/commands/login.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { defineCommand } from '../utils/command.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { logIn } from '../utils/login.js';
+import { printJson } from '../utils/output.js';
+import { readUserConfig, writeUserConfig } from '../utils/user-config.js';
+export default defineCommand({
+    description: 'Log in by approving a one-time code in the browser.',
+    authentication: 'optional',
+    examples: [
+        'hotcodepush login',
+        'hotcodepush login --api-url https://api.example.com --json',
+    ],
+    options: defineCommandOptions({
+        apiUrl: z
+            .url({
+            error: 'Expected an absolute http or https URL such as https://api.example.com',
+            protocol: z.regexes.httpProtocol,
+        })
+            .transform(apiUrl => apiUrl.replace(/\/+$/, ''))
+            .optional()
+            .describe('The API to log in to, kept in config.json for every later command. Defaults to the one kept there.'),
+    }),
+    action: async (options) => {
+        if (options.apiUrl !== undefined) {
+            writeUserConfig({ ...readUserConfig(), apiUrl: options.apiUrl });
+        }
+        const user = await logIn(options);
+        if (options.json) {
+            printJson({ user });
+        }
+        else {
+            console.log(`Logged in as ${user.name} (${user.email}).`);
+        }
+    },
+});

package/dist/commands/logout.js

@@ -0,0 +1,81 @@
+import { createApiAuthClient } from '../utils/auth-client.js';
+import { defineCommand } from '../utils/command.js';
+import { resolveApiError } from '../utils/error-mapping.js';
+import { NotLoggedInError } from '../utils/errors.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson } from '../utils/output.js';
+import { deleteToken, readStoredToken } from '../utils/token-store.js';
+import { readUserConfig, writeUserConfig } from '../utils/user-config.js';
+const UNAUTHORIZED_STATUS = 401;
+export default defineCommand({
+    description: 'End the stored session and remove its token. HOTCODEPUSH_TOKEN, when set, stays what it is.',
+    authentication: 'optional',
+    examples: ['hotcodepush logout', 'hotcodepush logout --json'],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const storedToken = readStoredToken();
+        if (storedToken === undefined) {
+            if (!process.env.HOTCODEPUSH_TOKEN) {
+                throw new NotLoggedInError();
+            }
+            printEnded({ id: null, name: null }, options.json);
+            return;
+        }
+        const authClient = createApiAuthClient(storedToken);
+        const knownSession = await fetchKnownSession(authClient);
+        const { error } = await authClient.revokeSession({
+            token: resolveUnsignedToken(storedToken),
+        });
+        // A 401 means the session already ended, so only the stored copies are left to clear.
+        if (error !== null && error.status !== UNAUTHORIZED_STATUS) {
+            throw resolveApiError(error);
+        }
+        deleteToken();
+        const storedSessionId = deleteStoredSession();
+        printEnded({
+            id: knownSession?.session.id ?? storedSessionId ?? null,
+            name: knownSession?.user.name ?? null,
+        }, options.json);
+    },
+});
+function deleteStoredSession() {
+    const userConfig = readUserConfig();
+    const { sessionId } = userConfig;
+    if (sessionId === undefined && userConfig.sessionExpiresAt === undefined) {
+        return undefined;
+    }
+    delete userConfig.sessionExpiresAt;
+    delete userConfig.sessionId;
+    writeUserConfig(userConfig);
+    return sessionId;
+}
+async function fetchKnownSession(authClient) {
+    const { data, error } = await authClient.getSession();
+    if (error !== null) {
+        if (error.status === UNAUTHORIZED_STATUS) {
+            return null;
+        }
+        throw resolveApiError(error);
+    }
+    return data;
+}
+function printEnded(endedSession, isJson) {
+    if (isJson) {
+        printJson(endedSession);
+        return;
+    }
+    const variableText = process.env.HOTCODEPUSH_TOKEN
+        ? ' HOTCODEPUSH_TOKEN still authenticates.'
+        : '';
+    if (endedSession.id === null && endedSession.name === null) {
+        console.log(`No stored session to end.${variableText}`);
+        return;
+    }
+    const nameText = endedSession.name === null ? '' : ` ${endedSession.name}`;
+    console.log(`Logged out${nameText}.${variableText}`);
+}
+// A bearer can be signed, `<token>.<signature>`, but revoke-session looks up the token alone.
+function resolveUnsignedToken(token) {
+    const [unsignedToken = token] = token.split('.');
+    return unsignedToken;
+}

package/dist/commands/member/delete.js

@@ -0,0 +1,35 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { fetchMember, memberOptionShape, resolveMemberEmail, } from '../../utils/member-resolution.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Remove a member from the organization, or yourself to leave it. The Owner leaves only after transferring the ownership.',
+    examples: [
+        'hotcodepush member delete --member bob@example.com',
+        'hotcodepush member delete --member 5e8a2c71-0b4d-4f39-9a6e-3c1d7b2f8e40 --yes --json',
+    ],
+    options: defineCommandOptions(memberOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const fetchedMember = await fetchMember(hotCodePush, organizationId, options);
+        const email = resolveMemberEmail(fetchedMember);
+        const isConfirmed = await confirmConsequence(`removes member ${email} from the organization`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.organizations.members.delete({
+            memberId: fetchedMember.id,
+            organizationId,
+        });
+        if (options.json) {
+            printJson({ id: fetchedMember.id, name: email });
+        }
+        else {
+            console.log(`Removed member ${email} (${fetchedMember.id}).`);
+        }
+    },
+});

package/dist/commands/member/get.js

@@ -0,0 +1,37 @@
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommand } from '../../utils/command.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { fetchMember, memberOptionShape, resolveMemberEmail, } from '../../utils/member-resolution.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Print a member of the organization with their role and how they sign in.',
+    examples: [
+        'hotcodepush member get --member anna@example.com',
+        'hotcodepush member get --member 2a7d4e91-6c3b-4f58-8e0a-9b1c5d3f7e62 --json',
+    ],
+    options: defineCommandOptions(memberOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedMember = await fetchMember(hotCodePush, await fetchOrganizationId(hotCodePush, options), options);
+        if (options.json) {
+            printJson(fetchedMember);
+            return;
+        }
+        printDetails([
+            ['ID', fetchedMember.id],
+            ['Name', fetchedMember.user?.name ?? ''],
+            ['Email', resolveMemberEmail(fetchedMember)],
+            ['Role', fetchedMember.role],
+            ['Password', hasPasswordAccount(fetchedMember) ? 'yes' : 'no'],
+            ['Two-factor', fetchedMember.user?.twoFactorEnabled ? 'yes' : 'no'],
+            ['Last seen', fetchedMember.lastSeenAt ?? 'never'],
+            ['Joined', fetchedMember.createdAt],
+        ]);
+    },
+});
+// Better Auth stores a password as an account of the provider `credential`.
+function hasPasswordAccount({ user }) {
+    return (user?.accounts?.some(({ providerId }) => providerId === 'credential') ??
+        false);
+}

package/dist/commands/member/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 { resolveMemberEmail } from '../../utils/member-resolution.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 the organization's members with their roles, newest first.",
+    examples: [
+        'hotcodepush member list --organization Acme',
+        'hotcodepush member list --limit 10 --offset 10 --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedMembers = await hotCodePush.organizations.members.list({
+            limit: options.limit,
+            offset: options.offset,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+            relations: ['user', 'user.accounts'],
+        });
+        const nextOffset = resolveNextOffset(listedMembers.length, options);
+        if (options.json) {
+            printJson({ members: listedMembers, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No members.',
+            headers: ['ID', 'NAME', 'EMAIL', 'ROLE', 'JOINED'],
+            nextOffset,
+            rows: listedMembers.map(member => [
+                member.id,
+                member.user?.name ?? '',
+                resolveMemberEmail(member),
+                member.role,
+                resolveDate(member.createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/member/update.js

@@ -0,0 +1,53 @@
+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 { fetchMember, memberOptionShape, resolveMemberEmail, } from '../../utils/member-resolution.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence, promptSelect } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+const MEMBER_ROLES = [
+    'admin',
+    'billing',
+    'member',
+    'owner',
+];
+export default defineCommand({
+    description: "Change a member's role; --role owner transfers the ownership to them, makes you an admin and asks once, --yes confirming in scripts.",
+    examples: [
+        'hotcodepush member update --member bob@example.com --role admin',
+        'hotcodepush member update --member 5e8a2c71-0b4d-4f39-9a6e-3c1d7b2f8e40 --role owner --yes',
+    ],
+    options: defineCommandOptions({
+        ...memberOptionShape,
+        role: z
+            .enum(MEMBER_ROLES)
+            .optional()
+            .describe("The member's new role: admin, billing, member, or owner to transfer the ownership."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const fetchedMember = await fetchMember(hotCodePush, organizationId, options);
+        const role = options.role ??
+            (await promptSelect('--role', 'Which role does the member get?', MEMBER_ROLES.map(role => ({ label: role, value: role })), options));
+        const email = resolveMemberEmail(fetchedMember);
+        if (role === 'owner') {
+            const isConfirmed = await confirmConsequence(`transfers the ownership of the organization to ${email} and makes you an admin, and only the new owner can transfer it back`, options);
+            if (!isConfirmed) {
+                return;
+            }
+        }
+        const updatedMember = await hotCodePush.organizations.members.update({
+            memberId: fetchedMember.id,
+            organizationId,
+            role,
+        });
+        if (options.json) {
+            printJson(updatedMember);
+        }
+        else {
+            console.log(`Updated member ${email} (${updatedMember.id}) to role ${updatedMember.role}.`);
+        }
+    },
+});

package/dist/commands/open.js

@@ -0,0 +1,37 @@
+import { createApiClient } from '../utils/api-client.js';
+import { openBrowser } from '../utils/browser.js';
+import { defineCommand } from '../utils/command.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { resolveConsoleBaseUrl } from '../utils/hosts.js';
+import { printJson } from '../utils/output.js';
+import { assertProjectConfigAppId, readProjectConfig, } from '../utils/project-config.js';
+import { channelOptionShape, fetchAppId, fetchChannel, } from '../utils/resource-resolution.js';
+import { readApiUrl } from '../utils/user-config.js';
+export default defineCommand({
+    description: "Open the app's console page in the browser, or the channel's, from hotcodepush.json.",
+    examples: ['hotcodepush open', 'hotcodepush open --channel staging'],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const url = await resolveConsolePageUrl(options);
+        if (options.json) {
+            printJson({ url });
+            return;
+        }
+        console.log(`Opening ${url}`);
+        await openBrowser(url);
+    },
+});
+async function resolveConsolePageUrl(options) {
+    const consoleBaseUrl = resolveConsoleBaseUrl(readApiUrl());
+    if (options.channel !== undefined) {
+        const channel = await fetchChannel(createApiClient(), options);
+        return `${consoleBaseUrl}/apps/${channel.appId}/channels/${channel.id}`;
+    }
+    const projectConfig = readProjectConfig(options.config);
+    if (options.app === undefined && projectConfig?.appId !== undefined) {
+        assertProjectConfigAppId(projectConfig.appId);
+        return `${consoleBaseUrl}/apps/${projectConfig.appId}`;
+    }
+    const appId = await fetchAppId(createApiClient(), options, projectConfig);
+    return `${consoleBaseUrl}/apps/${appId}`;
+}

package/dist/commands/organization/create.js

@@ -0,0 +1,30 @@
+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 { promptText } from '../../utils/prompts.js';
+export default defineCommand({
+    description: 'Create an organization with you as its Owner.',
+    examples: [
+        'hotcodepush organization create --name Acme',
+        'hotcodepush organization create --name Acme --json',
+    ],
+    options: defineCommandOptions({
+        name: z.string().optional().describe("The organization's name."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const name = options.name ??
+            (await promptText('--name', 'What is the organization called?', options));
+        const createdOrganization = await hotCodePush.organizations.create({
+            name,
+        });
+        if (options.json) {
+            printJson(createdOrganization);
+        }
+        else {
+            console.log(`Created organization ${createdOrganization.name} (${createdOrganization.id}).`);
+        }
+    },
+});

package/dist/commands/organization/delete.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, resolveQuantityText } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchApps, fetchOrganizationId, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Delete an organization with everything in it. Support can restore it for seven days.',
+    examples: [
+        'hotcodepush organization delete --organization Acme',
+        'hotcodepush organization delete --organization Acme --yes --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const [fetchedOrganization, fetchedApps] = await Promise.all([
+            hotCodePush.organizations.get({ organizationId }),
+            fetchApps(hotCodePush, organizationId),
+        ]);
+        const isConfirmed = await confirmConsequence(resolveDeletionConsequence(fetchedOrganization.name, fetchedApps.length), options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.organizations.delete({ organizationId });
+        if (options.json) {
+            printJson({ id: organizationId, name: fetchedOrganization.name });
+        }
+        else {
+            console.log(`Deleted organization ${fetchedOrganization.name} (${organizationId}).`);
+        }
+    },
+});
+function resolveDeletionConsequence(organizationName, appCount) {
+    const deletion = `deletes organization ${organizationName}`;
+    return appCount === 0
+        ? deletion
+        : `${deletion} and its ${resolveQuantityText(appCount, 'app')}`;
+}