hotcodepush 0.0.1 → 0.1.0

package/dist/commands/invitation/list.js

@@ -0,0 +1,40 @@
+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 { 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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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,185 @@
+import { setTimeout } from 'node:timers/promises';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { CLI_CLIENT_ID } from '../config/consts.js';
+import { createApiAuthClient, fetchSession, resolveResponseData, } from '../utils/auth-client.js';
+import { openBrowser } from '../utils/browser.js';
+import { isInteractive } from '../utils/environment.js';
+import { resolveApiError } from '../utils/error-mapping.js';
+import { LoginDeniedError, LoginExpiredError, NotLoggedInError, } from '../utils/errors.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson } from '../utils/output.js';
+import { writeToken } from '../utils/token-store.js';
+import { readUserConfig, writeUserConfig } from '../utils/user-config.js';
+// RFC 8628, section 3.2: without an interval from the server, a client polls every five seconds.
+const DEFAULT_INTERVAL_SECONDS = 5;
+const DEVICE_CODE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:device_code';
+// RFC 8628, section 3.5: each slow_down adds five seconds to this and every later interval.
+const SLOW_DOWN_INCREMENT_SECONDS = 5;
+export default defineCommand({
+    description: 'Log in by approving a one-time code in the browser.',
+    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; the one kept there otherwise.'),
+    }),
+    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}).`);
+        }
+    },
+});
+// The page and the code go to stderr, so the stdout of the calling command stays its own.
+export async function logIn(options) {
+    const authClient = createApiAuthClient();
+    const sessionToken = await fetchSessionToken(authClient, isInteractive(options));
+    const { session, user } = await fetchSession(createApiAuthClient(sessionToken));
+    writeToken(sessionToken);
+    deletePendingDeviceAuthorization();
+    writeUserConfig({ ...readUserConfig(), sessionId: session.id });
+    return { email: user.email, id: user.id, name: user.name };
+}
+// A request without an answer or with a transient status is polled again, since the person may be approving meanwhile.
+async function fetchApprovedSessionToken(authClient, deviceAuthorization) {
+    let currentIntervalSeconds = deviceAuthorization.intervalSeconds;
+    for (;;) {
+        await setTimeout(currentIntervalSeconds * 1000);
+        if (isDeviceAuthorizationExpired(deviceAuthorization)) {
+            throw new LoginExpiredError();
+        }
+        const response = await fetchDeviceToken(authClient, deviceAuthorization.deviceCode).catch(() => undefined);
+        if (response === undefined) {
+            continue;
+        }
+        const { data, error } = response;
+        if (error === null) {
+            return data.access_token;
+        }
+        switch (error.error) {
+            case 'access_denied':
+                throw new LoginDeniedError();
+            case 'authorization_pending':
+                break;
+            case 'expired_token':
+                throw new LoginExpiredError();
+            case 'slow_down':
+                currentIntervalSeconds += SLOW_DOWN_INCREMENT_SECONDS;
+                break;
+            default:
+                if (!isTransientStatus(error.status)) {
+                    throw resolveApiError(error);
+                }
+        }
+    }
+}
+async function fetchDeviceAuthorization(authClient) {
+    const { device_code, expires_in, interval, user_code, verification_uri_complete, } = resolveResponseData(await authClient.device.code({ client_id: CLI_CLIENT_ID }));
+    return {
+        deviceCode: device_code,
+        expiresAt: new Date(Date.now() + expires_in * 1000).toISOString(),
+        intervalSeconds: interval,
+        userCode: user_code,
+        verificationUrl: verification_uri_complete,
+    };
+}
+function fetchDeviceToken(authClient, deviceCode) {
+    return authClient.device.token({
+        client_id: CLI_CLIENT_ID,
+        device_code: deviceCode,
+        grant_type: DEVICE_CODE_GRANT_TYPE,
+    });
+}
+// A code that a non-interactive login kept is redeemed first, with one token request.
+// While pending it is shown again. Denied, expired or unknown, it gives way to a new one.
+async function fetchSessionToken(authClient, isLoginInteractive) {
+    const pendingDeviceAuthorization = readPendingDeviceAuthorization();
+    if (pendingDeviceAuthorization !== undefined &&
+        !isDeviceAuthorizationExpired(pendingDeviceAuthorization)) {
+        const { data, error } = await fetchDeviceToken(authClient, pendingDeviceAuthorization.deviceCode);
+        if (error === null) {
+            return data.access_token;
+        }
+        switch (error.error) {
+            case 'access_denied':
+            case 'expired_token':
+            case 'invalid_grant':
+                break;
+            case 'authorization_pending':
+            case 'slow_down':
+                return fetchSessionTokenOnApproval(authClient, pendingDeviceAuthorization, isLoginInteractive);
+            default:
+                throw resolveApiError(error);
+        }
+    }
+    deletePendingDeviceAuthorization();
+    return fetchSessionTokenOnApproval(authClient, await fetchDeviceAuthorization(authClient), isLoginInteractive);
+}
+// The code is kept, so the next login redeems one that ended before the approval.
+async function fetchSessionTokenOnApproval(authClient, deviceAuthorization, isLoginInteractive) {
+    writePendingDeviceAuthorization(deviceAuthorization);
+    if (!isLoginInteractive) {
+        throw new NotLoggedInError(deviceAuthorization);
+    }
+    process.stderr.write(`Open ${deviceAuthorization.verificationUrl} and approve the code ${deviceAuthorization.userCode}.\nWaiting for the approval…\n`);
+    await openBrowser(deviceAuthorization.verificationUrl);
+    return fetchApprovedSessionToken(authClient, deviceAuthorization);
+}
+function deletePendingDeviceAuthorization() {
+    const userConfig = readUserConfig();
+    if (userConfig.pendingDeviceCode === undefined) {
+        return;
+    }
+    delete userConfig.pendingDeviceCode;
+    delete userConfig.pendingDeviceCodeExpiresAt;
+    delete userConfig.pendingUserCode;
+    delete userConfig.pendingVerificationUrl;
+    writeUserConfig(userConfig);
+}
+function isDeviceAuthorizationExpired({ expiresAt, }) {
+    return new Date(expiresAt) <= new Date();
+}
+// The statuses the Node client also retries: a timeout, the rate limit or a server error.
+function isTransientStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function readPendingDeviceAuthorization() {
+    const { pendingDeviceCode, pendingDeviceCodeExpiresAt, pendingUserCode, pendingVerificationUrl, } = readUserConfig();
+    if (pendingDeviceCode === undefined ||
+        pendingDeviceCodeExpiresAt === undefined ||
+        pendingUserCode === undefined ||
+        pendingVerificationUrl === undefined) {
+        return undefined;
+    }
+    return {
+        deviceCode: pendingDeviceCode,
+        expiresAt: pendingDeviceCodeExpiresAt,
+        intervalSeconds: DEFAULT_INTERVAL_SECONDS,
+        userCode: pendingUserCode,
+        verificationUrl: pendingVerificationUrl,
+    };
+}
+function writePendingDeviceAuthorization({ deviceCode, expiresAt, userCode, verificationUrl, }) {
+    writeUserConfig({
+        ...readUserConfig(),
+        pendingDeviceCode: deviceCode,
+        pendingDeviceCodeExpiresAt: expiresAt,
+        pendingUserCode: userCode,
+        pendingVerificationUrl: verificationUrl,
+    });
+}

package/dist/commands/logout.js

@@ -0,0 +1,79 @@
+import { defineCommand } from 'zodline';
+import { createApiAuthClient } from '../utils/auth-client.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.',
+    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 = deleteSessionId();
+        printEnded({
+            id: knownSession?.session.id ?? storedSessionId ?? null,
+            name: knownSession?.user.name ?? null,
+        }, options.json);
+    },
+});
+function deleteSessionId() {
+    const userConfig = readUserConfig();
+    const { sessionId } = userConfig;
+    if (sessionId === undefined) {
+        return undefined;
+    }
+    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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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; 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 { defineCommand } from 'zodline';
+import { createApiClient } from '../utils/api-client.js';
+import { openBrowser } from '../utils/browser.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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')}`;
+}

package/dist/commands/organization/get.js

@@ -0,0 +1,38 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+import { resolveDollarText } from '../../utils/spending-cap.js';
+export default defineCommand({
+    description: 'Print an organization with its plan, spending cap and region.',
+    examples: [
+        'hotcodepush organization get --organization Acme',
+        'hotcodepush organization get --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedOrganization = await hotCodePush.organizations.get({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(fetchedOrganization);
+            return;
+        }
+        printOrganizationDetails(fetchedOrganization);
+    },
+});
+export function printOrganizationDetails(organization) {
+    printDetails([
+        ['ID', organization.id],
+        ['Name', organization.name],
+        ['Plan', organization.plan],
+        [
+            'Spending cap',
+            `${resolveDollarText(organization.spendingCapCents)} a month`,
+        ],
+        ['Region', organization.region],
+        ['Created', organization.createdAt],
+    ]);
+}