hotcodepush 0.0.0 → 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,492 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { HotCodePushError } from '@hotcodepush/node';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { DOCS_URL, PROJECT_CONFIG_FILE_NAME, SIGNING_PRIVATE_KEY_FILE_NAME, } from '../config/consts.js';
+import { createApiClient } from '../utils/api-client.js';
+import { fetchCurrentUser, isUnauthenticatedError, resolveCredentialText, } from '../utils/credential.js';
+import { isInteractive } from '../utils/environment.js';
+import { ConfirmationRequiredError, InvalidParameterError, MissingParameterError, NotLoggedInError, ReportedFailureError, UnexpectedError, } from '../utils/errors.js';
+import { detectFramework } from '../utils/framework.js';
+import { resolveFrameworkModule } from '../utils/frameworks/index.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { resolveConsoleBaseUrl } from '../utils/hosts.js';
+import { InitRun, resolveStepRows } from '../utils/init-steps.js';
+import { stringifyLikeSource } from '../utils/json-file.js';
+import { printOutcomeRows } from '../utils/outcome.js';
+import { printJson } from '../utils/output.js';
+import { readPackageJson } from '../utils/package-json.js';
+import { resolveCommandLineText, resolvePackageManager, resolveRunScriptCommandLine, runCommandLineVisibly, } from '../utils/package-manager.js';
+import { ID_SCHEMA, locateProjectConfig, resolveProjectChannel, } from '../utils/project-config.js';
+import { confirmConsequence, promptSelect, promptText, promptYesNo, } from '../utils/prompts.js';
+import { fetchApps, fetchHasSigningKey, fetchOrganizations, } from '../utils/resource-resolution.js';
+import { isEnvironmentToken, readToken } from '../utils/token-store.js';
+import { readApiUrl } from '../utils/user-config.js';
+import { logIn } from './login.js';
+import releaseCreateCommand from './release/create.js';
+import signingKeyCreateCommand from './signing-key/create.js';
+const CREATE_CHOICE = 'create';
+export default defineCommand({
+    description: 'Set a React Native, Expo, Capacitor or Cordova project up from sign-in to the first release, re-runnable at any step.',
+    examples: ['hotcodepush init', 'hotcodepush init --yes --json'],
+    options: defineCommandOptions({
+        androidPath: z
+            .string()
+            .optional()
+            .describe("The Android project, when it is not capacitor.config's android.path or android/."),
+        framework: z
+            .enum(['react_native', 'expo', 'capacitor', 'cordova'])
+            .optional()
+            .describe('The framework, react_native, expo, capacitor or cordova, over the one detected from package.json.'),
+        iosPath: z
+            .string()
+            .optional()
+            .describe("The iOS project, when it is not capacitor.config's ios.path or ios/."),
+        xcodeTarget: z
+            .string()
+            .optional()
+            .describe('The app target that gets the build step phase, when the iOS project has several.'),
+    }),
+    action: async (options) => {
+        const projectConfigLocation = locateProjectConfig(options.config);
+        const { directoryPath, projectConfig } = projectConfigLocation;
+        const framework = options.framework ?? detectFramework(directoryPath);
+        const frameworkModule = resolveFrameworkModule(framework);
+        const run = new InitRun();
+        const hotCodePush = await run.run('sign_in', () => signIn(options));
+        const scope = await run.run('organization', () => resolveOrganization(requireValue(hotCodePush), projectConfig, options), { dependsOn: ['sign_in'] });
+        const app = await run.run('app', () => resolveApp(requireValue(hotCodePush), requireValue(scope), projectConfigLocation, framework, options), { dependsOn: ['organization'] });
+        const projectFiles = await resolveProjectFiles(projectConfigLocation, frameworkModule, options);
+        const editBlocker = await resolveEditBlocker(projectFiles, app, options);
+        await run.run('package', () => installPackage(projectFiles, editBlocker));
+        await run.run('configuration', () => writeConfiguration(requireValue(hotCodePush), projectFiles, requireValue(app), editBlocker), { dependsOn: ['app'] });
+        await run.run('hook', () => projectFiles.wiring.wireBinaryCreateStep(editBlocker));
+        const privateKeyPath = await run.run('signing_key', () => createSigningKey(app, projectFiles, options));
+        const isReleaseWanted = run.stoppedCode === undefined &&
+            (await promptYesNo('Publish a first release now?', options));
+        const isBuilt = await run.run('build', () => buildProject(projectFiles, isReleaseWanted));
+        const isReleased = await run.run('release', () => releaseFirst(projectFiles, isReleaseWanted, isBuilt === true, privateKeyPath, options), { dependsOn: ['configuration', 'build'] });
+        const status = run.stoppedCode === undefined ? 'complete' : 'incomplete';
+        if (options.json) {
+            printJson({ status, steps: run.steps });
+        }
+        else {
+            // A blank line separates the rows from the package manager and build output above them.
+            console.log('');
+            printOutcomeRows(resolveStepRows(run.steps));
+            if (app !== undefined && status === 'complete') {
+                printFinish(app, isReleased === true, privateKeyPath);
+            }
+        }
+        if (run.stoppedCode !== undefined) {
+            throw new ReportedFailureError(run.stoppedCode, run.stoppedStep);
+        }
+    },
+});
+// A non-interactive login leaves the device code for the next run.
+async function signIn(options) {
+    if (readToken() !== undefined) {
+        try {
+            return {
+                message: resolveCredentialText(await fetchCurrentUser(), isEnvironmentToken()),
+                status: 'skipped',
+                value: createApiClient(),
+            };
+        }
+        catch (error) {
+            if (!isUnauthenticatedError(error) &&
+                !(error instanceof NotLoggedInError)) {
+                throw error;
+            }
+        }
+    }
+    const user = await logIn(options);
+    return {
+        message: `Logged in as ${user.name} (${user.email}).`,
+        status: 'done',
+        value: createApiClient(),
+    };
+}
+// Without `--organization`, a person picks or creates one. Non-interactively the only one is used.
+async function resolveOrganization(hotCodePush, projectConfig, options) {
+    const app = options.app === undefined && projectConfig?.appId !== undefined
+        ? await fetchExistingApp(hotCodePush, projectConfig.appId)
+        : undefined;
+    if (app !== undefined) {
+        const organization = await hotCodePush.organizations.get({
+            organizationId: app.organizationId,
+        });
+        return {
+            message: `Used organization ${organization.name}, the one of ${PROJECT_CONFIG_FILE_NAME}'s app.`,
+            status: 'done',
+            value: { app, organization },
+        };
+    }
+    const organizations = await fetchOrganizations(hotCodePush);
+    if (options.organization !== undefined) {
+        const named = findNamed(organizations, options.organization);
+        if (named !== undefined) {
+            return resolveUsedScope(named);
+        }
+        assertName('--organization', options.organization);
+        await confirmCreation('organization', options.organization, options);
+        return resolveCreatedScope(await hotCodePush.organizations.create({ name: options.organization }));
+    }
+    const [onlyOrganization] = organizations;
+    if (!isInteractive(options) &&
+        onlyOrganization !== undefined &&
+        organizations.length === 1) {
+        return resolveUsedScope(onlyOrganization);
+    }
+    const choice = await promptCreateOrPick('organization', organizations, options);
+    if (choice !== CREATE_CHOICE) {
+        return resolveUsedScope(requireById(organizations, choice));
+    }
+    const name = await promptText('--organization', 'What is the new organization called?', options);
+    return resolveCreatedScope(await hotCodePush.organizations.create({ name }));
+}
+// An app in the file that the API lacks is refused non-interactively. A person picks or creates another.
+async function resolveApp(hotCodePush, { app, organization }, { filePath, projectConfig }, framework, options) {
+    if (app !== undefined) {
+        return {
+            message: `Used app ${app.name}, as ${PROJECT_CONFIG_FILE_NAME} names it.`,
+            status: 'done',
+            value: app,
+        };
+    }
+    if (options.app === undefined &&
+        projectConfig?.appId !== undefined &&
+        !isInteractive(options)) {
+        throw new InvalidParameterError(`The app ${projectConfig.appId} in ${filePath ?? PROJECT_CONFIG_FILE_NAME} does not exist.`, `Pass --app with the app's id or name, or delete ${PROJECT_CONFIG_FILE_NAME} to create a new app.`);
+    }
+    const apps = await fetchApps(hotCodePush, organization.id);
+    if (options.app !== undefined) {
+        const named = findNamed(apps, options.app);
+        if (named !== undefined) {
+            return resolveUsed('app', named);
+        }
+        assertName('--app', options.app);
+        await confirmCreation('app', options.app, options);
+        return resolveCreated('app', await hotCodePush.organizations.apps.create({
+            framework,
+            name: options.app,
+            organizationId: organization.id,
+        }));
+    }
+    const [onlyApp] = apps;
+    if (!isInteractive(options) && onlyApp !== undefined && apps.length === 1) {
+        return resolveUsed('app', onlyApp);
+    }
+    const choice = await promptCreateOrPick('app', apps, options);
+    if (choice !== CREATE_CHOICE) {
+        return resolveUsed('app', requireById(apps, choice));
+    }
+    const name = await promptText('--app', 'What is the app called?', options);
+    return resolveCreated('app', await hotCodePush.organizations.apps.create({
+        framework,
+        name,
+        organizationId: organization.id,
+    }));
+}
+async function resolveProjectFiles({ directoryPath, filePath, projectConfig }, framework, options) {
+    const packageJson = readPackageJson(directoryPath);
+    return {
+        configFilePath: filePath ?? join(directoryPath, PROJECT_CONFIG_FILE_NAME),
+        directoryPath,
+        framework,
+        packageJson,
+        projectConfig,
+        wiring: await framework.resolveWiring({ directoryPath, packageJson }, options),
+    };
+}
+// Declined, or with nobody to ask, each editing step stops with that reason.
+async function resolveEditBlocker(projectFiles, app, options) {
+    const filePaths = resolveFilesToChange(projectFiles, app);
+    if (filePaths.length === 0) {
+        return undefined;
+    }
+    const consequence = `changes ${filePaths.join(', ')}`;
+    const manualStep = `Run "hotcodepush init --yes" to change ${filePaths.join(', ')}.`;
+    try {
+        return (await confirmConsequence(consequence, options))
+            ? undefined
+            : new ConfirmationRequiredError(consequence, manualStep);
+    }
+    catch (error) {
+        if (error instanceof ConfirmationRequiredError) {
+            return new ConfirmationRequiredError(consequence, manualStep);
+        }
+        throw error;
+    }
+}
+// Without an app the configuration step waits, so `hotcodepush.json` is not among the files.
+function resolveFilesToChange({ configFilePath, projectConfig, wiring }, app) {
+    return [
+        ...wiring.packageFilePaths,
+        ...(app === undefined || isConfigurationComplete(projectConfig, app)
+            ? []
+            : [basename(configFilePath)]),
+        ...wiring.nativeFilePaths,
+    ];
+}
+function installPackage({ framework, wiring }, editBlocker) {
+    if (wiring.isPackageInstalled) {
+        return Promise.resolve({
+            message: `The package ${framework.packageName} is already installed.`,
+            status: 'skipped',
+            value: undefined,
+        });
+    }
+    if (editBlocker !== undefined) {
+        throw editBlocker;
+    }
+    return Promise.resolve({
+        message: wiring.installPackage(),
+        status: 'done',
+        value: undefined,
+    });
+}
+async function writeConfiguration(hotCodePush, { configFilePath, projectConfig }, app, editBlocker) {
+    if (isConfigurationComplete(projectConfig, app)) {
+        return {
+            message: `The file ${basename(configFilePath)} is already present.`,
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    if (editBlocker !== undefined) {
+        throw editBlocker;
+    }
+    const sourceText = existsSync(configFilePath)
+        ? readFileSync(configFilePath, 'utf8')
+        : '';
+    writeFileSync(configFilePath, stringifyLikeSource({
+        ...projectConfig,
+        appId: app.id,
+        ...(projectConfig?.channel !== undefined
+            ? {}
+            : { channel: await fetchDefaultChannelName(hotCodePush, app) }),
+    }, sourceText || '{}\n'));
+    return {
+        message: resolveConfigurationMessage(basename(configFilePath), projectConfig, app),
+        status: 'done',
+        value: undefined,
+    };
+}
+function resolveConfigurationMessage(fileName, projectConfig, app) {
+    if (projectConfig === undefined) {
+        return `Wrote ${fileName}.`;
+    }
+    if (projectConfig.appId !== undefined && projectConfig.appId !== app.id) {
+        return `Set the app in ${fileName} to ${app.name}.`;
+    }
+    return `Completed ${fileName}.`;
+}
+async function fetchDefaultChannelName(hotCodePush, app) {
+    if (app.defaultChannelId === null) {
+        return resolveProjectChannel({});
+    }
+    const defaultChannel = await hotCodePush.apps.channels.get({
+        appId: app.id,
+        channelId: app.defaultChannelId,
+    });
+    return defaultChannel.name;
+}
+// Nobody to ask points at the command instead, since a key file written on a runner is lost with it.
+async function createSigningKey(app, { configFilePath }, options) {
+    if (app !== undefined &&
+        (await fetchHasSigningKey(createApiClient(), app.id))) {
+        return {
+            message: 'The app already has a signing key.',
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    if (app === undefined ||
+        !(await promptYesNo('Generate a signing key pair?', options))) {
+        return {
+            message: 'Run "hotcodepush signing-key create" to enable code signing.',
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    const privateKeyPath = SIGNING_PRIVATE_KEY_FILE_NAME;
+    await signingKeyCreateCommand.action({
+        app: app.id,
+        config: existsSync(configFilePath) ? configFilePath : undefined,
+        json: options.json,
+        privateKeyPath,
+    }, undefined);
+    return {
+        message: 'Generated a signing key pair, its private key in the file named above.',
+        status: 'done',
+        value: privateKeyPath,
+    };
+}
+function buildProject({ directoryPath, framework, packageJson }, isReleaseWanted) {
+    if (framework.packageBundles !== undefined) {
+        return Promise.resolve({
+            message: 'The command "hotcodepush release create" packages the bundles itself.',
+            status: 'skipped',
+            value: false,
+        });
+    }
+    const buildCommandLine = resolveBuildCommandLine(directoryPath, packageJson);
+    if (buildCommandLine === undefined) {
+        return Promise.resolve({
+            message: 'There is no build script in package.json.',
+            status: 'skipped',
+            value: false,
+        });
+    }
+    if (!isReleaseWanted) {
+        return Promise.resolve({
+            message: 'No release follows.',
+            status: 'skipped',
+            value: false,
+        });
+    }
+    runCommandLineVisibly(buildCommandLine, directoryPath);
+    return Promise.resolve({
+        message: `Ran "${resolveCommandLineText(buildCommandLine)}".`,
+        status: 'done',
+        value: true,
+    });
+}
+async function releaseFirst({ configFilePath, directoryPath, framework, packageJson }, isReleaseWanted, isBuilt, privateKeyPath, options) {
+    const releaseCommandText = resolveReleaseCommandText(privateKeyPath);
+    if (!isReleaseWanted) {
+        const buildCommandLine = framework.packageBundles === undefined
+            ? resolveBuildCommandLine(directoryPath, packageJson)
+            : undefined;
+        return {
+            message: buildCommandLine === undefined
+                ? `Run "${releaseCommandText}" to publish the first release.`
+                : `Run "${resolveCommandLineText(buildCommandLine)}", then "${releaseCommandText}" to publish the first release.`,
+            status: 'skipped',
+            value: false,
+        };
+    }
+    const buildDirectory = framework.readBuildDirectory(directoryPath);
+    if (framework.packageBundles === undefined &&
+        !isBuilt &&
+        'path' in buildDirectory &&
+        !existsSync(join(directoryPath, buildDirectory.path))) {
+        const buildCommandLine = resolveBuildCommandLine(directoryPath, packageJson);
+        return {
+            message: `There is ${buildCommandLine === undefined ? 'no build script and ' : ''}no output at ${buildDirectory.path}. Build, then run "${releaseCommandText}".`,
+            status: 'skipped',
+            value: false,
+        };
+    }
+    await releaseCreateCommand.action({
+        config: configFilePath,
+        json: options.json,
+        privateKeyPath,
+        yes: true,
+    }, undefined);
+    return {
+        message: 'Released to production.',
+        status: 'done',
+        value: true,
+    };
+}
+// A skipped release row already names the release command, so it is repeated only after a release.
+function printFinish(app, isReleased, privateKeyPath) {
+    console.log('');
+    console.log(isReleased
+        ? `Build the app natively once and run it; change a line, run the build and "${resolveReleaseCommandText(privateKeyPath)}", then reopen the app.`
+        : 'Build the app natively once and run it, then publish the first release as shown above.');
+    console.log(`Console: ${resolveConsoleBaseUrl(readApiUrl())}/apps/${app.id}`);
+    console.log(`Docs: ${DOCS_URL}`);
+}
+function assertName(flag, reference) {
+    if (ID_SCHEMA.safeParse(reference).success) {
+        throw new InvalidParameterError(`Nothing has the id ${reference} from ${flag}.`);
+    }
+}
+async function confirmCreation(noun, name, options) {
+    const isConfirmed = await confirmConsequence(`creates the ${noun} ${name}, which does not exist yet`, options);
+    if (!isConfirmed) {
+        throw new MissingParameterError(`--${noun}`);
+    }
+}
+// Such as a copied project, a cloned demo or a reset environment.
+async function fetchExistingApp(hotCodePush, appId) {
+    try {
+        return await hotCodePush.apps.get({ appId });
+    }
+    catch (error) {
+        if (error instanceof HotCodePushError && error.code === 'not_found') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function findNamed(resources, reference) {
+    return ID_SCHEMA.safeParse(reference).success
+        ? resources.find(({ id }) => id === reference)
+        : resources.find(({ name }) => name.toLowerCase() === reference.toLowerCase());
+}
+function isConfigurationComplete(projectConfig, app) {
+    return projectConfig?.appId === app.id && projectConfig.channel !== undefined;
+}
+function promptCreateOrPick(noun, resources, options) {
+    return promptSelect(`--${noun}`, `Which ${noun}?`, [
+        ...resources.map(({ id, name }) => ({ label: name, value: id })),
+        { label: `Create a new ${noun}`, value: CREATE_CHOICE },
+    ], options);
+}
+function requireById(resources, id) {
+    const resource = resources.find(candidate => candidate.id === id);
+    if (resource === undefined) {
+        throw new InvalidParameterError(`Nothing has the id ${id}.`);
+    }
+    return resource;
+}
+// A stopped step skips the rest, so the run never gets here without the value.
+function requireValue(value) {
+    if (value === undefined) {
+        throw new UnexpectedError(new Error('An earlier step did not run.'));
+    }
+    return value;
+}
+function resolveBuildCommandLine(directoryPath, packageJson) {
+    return packageJson.scripts?.build === undefined
+        ? undefined
+        : resolveRunScriptCommandLine(resolvePackageManager(directoryPath), 'build');
+}
+function resolveReleaseCommandText(privateKeyPath) {
+    return privateKeyPath === undefined
+        ? 'hotcodepush release create'
+        : `hotcodepush release create --private-key-path ${privateKeyPath}`;
+}
+function resolveCreatedScope(organization) {
+    return {
+        message: `Created organization ${organization.name}.`,
+        status: 'done',
+        value: { app: undefined, organization },
+    };
+}
+function resolveUsedScope(organization) {
+    return {
+        message: `Used organization ${organization.name}.`,
+        status: 'done',
+        value: { app: undefined, organization },
+    };
+}
+function resolveCreated(noun, resource) {
+    return {
+        message: `Created ${noun} ${resource.name}.`,
+        status: 'done',
+        value: resource,
+    };
+}
+function resolveUsed(noun, resource) {
+    return {
+        message: `Used ${noun} ${resource.name}.`,
+        status: 'done',
+        value: resource,
+    };
+}

package/dist/commands/invitation/accept.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { isInteractive } from '../../utils/environment.js';
+import { MissingParameterError } from '../../utils/errors.js';
+import { 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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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 { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.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;
+}