hotcodepush 0.0.1 → 0.2.0

package/dist/commands/fingerprint/diff.js

@@ -0,0 +1,134 @@
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { defineCommand } from '../../utils/command.js';
+import { InvalidParameterError } from '../../utils/errors.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable } from '../../utils/output.js';
+import { promptText } from '../../utils/prompts.js';
+const FINGERPRINT_FILE_FIX = 'Write each file with "hotcodepush fingerprint --json > <file>", the earlier one at the commit of the store build.';
+const FingerprintFileSchema = z.object({
+    fingerprint: z.string(),
+    extraFingerprintPaths: z.array(z.object({ path: z.string(), sha256: z.string() })),
+    packages: z.array(z.object({
+        integrity: z.string().nullable(),
+        name: z.string(),
+        version: z.string(),
+    })),
+});
+export default defineCommand({
+    description: 'Print the packages and extra fingerprint paths added, removed or moved between <file-a> and <file-b>, two files written by fingerprint --json, the earlier first. Runs locally without a login.',
+    authentication: 'optional',
+    examples: [
+        'hotcodepush fingerprint diff store-build.json current.json',
+        'hotcodepush fingerprint diff store-build.json current.json --json',
+    ],
+    args: z.array(z.string()),
+    options: defineCommandOptions({}),
+    action: async (options, args) => {
+        if (args.length > 2) {
+            throw new InvalidParameterError(`The fingerprint diff command compares two files, <file-a> and <file-b>. It does not take ${args.slice(2).join(' ')}.`);
+        }
+        const beforeFile = await readFingerprintFile('<file-a>', args[0] ??
+            (await promptText('<file-a>', "Which file holds the earlier fingerprint, the store build's?", options)));
+        const afterFile = await readFingerprintFile('<file-b>', args[1] ??
+            (await promptText('<file-b>', 'Which file holds the later fingerprint?', options)));
+        const diff = resolveFingerprintDiff(beforeFile, afterFile);
+        if (options.json) {
+            printJson(diff);
+            return;
+        }
+        if (diff.packages.length === 0 && diff.extraFingerprintPaths.length === 0) {
+            console.log(`Nothing moved: both files hold ${beforeFile.fingerprint}.`);
+            return;
+        }
+        printTable({
+            emptyText: 'No package moved.',
+            headers: ['PACKAGE', 'BEFORE', 'AFTER'],
+            nextOffset: null,
+            rows: diff.packages.map(({ after, before, name }) => [
+                name,
+                resolveInstalledVersionText(before, after),
+                resolveInstalledVersionText(after, before),
+            ]),
+        });
+        if (diff.extraFingerprintPaths.length > 0) {
+            printTable({
+                emptyText: '',
+                headers: ['EXTRA FINGERPRINT PATH', 'BEFORE', 'AFTER'],
+                nextOffset: null,
+                rows: diff.extraFingerprintPaths.map(({ after, before, path }) => [
+                    path,
+                    before ?? 'none',
+                    after ?? 'none',
+                ]),
+            });
+        }
+    },
+});
+async function readFingerprintFile(argumentName, filePath) {
+    const text = await readFile(filePath, 'utf8').catch((error) => {
+        throw new InvalidParameterError(`The file ${filePath} from ${argumentName} cannot be read.`, FINGERPRINT_FILE_FIX, error);
+    });
+    const parsedFile = FingerprintFileSchema.safeParse(parseJson(text));
+    if (!parsedFile.success) {
+        throw new InvalidParameterError(`The file ${filePath} from ${argumentName} is not a fingerprint written by fingerprint --json.`, FINGERPRINT_FILE_FIX, parsedFile.error);
+    }
+    return parsedFile.data;
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveFingerprintDiff(before, after) {
+    return {
+        extraFingerprintPaths: resolveExtraFingerprintPathChanges(before.extraFingerprintPaths, after.extraFingerprintPaths),
+        packages: resolvePackageChanges(before.packages, after.packages),
+    };
+}
+// Pairs the versions in order: a pair moved, the rest was added or removed.
+function resolvePackageChanges(before, after) {
+    const names = [...new Set([...before, ...after].map(({ name }) => name))];
+    return names.sort().flatMap(name => {
+        const beforeVersions = resolveVersionsOnlyIn(before, after, name);
+        const afterVersions = resolveVersionsOnlyIn(after, before, name);
+        return Array.from({ length: Math.max(beforeVersions.length, afterVersions.length) }, (_, index) => ({
+            after: afterVersions[index] ?? null,
+            before: beforeVersions[index] ?? null,
+            name,
+        }));
+    });
+}
+function resolveVersionsOnlyIn(packages, otherPackages, name) {
+    return packages
+        .filter(locked => locked.name === name &&
+        !otherPackages.some(other => other.name === name &&
+            other.version === locked.version &&
+            other.integrity === locked.integrity))
+        .map(({ integrity, version }) => ({ integrity, version }));
+}
+function resolveExtraFingerprintPathChanges(before, after) {
+    const beforeHashes = new Map(before.map(({ path, sha256 }) => [path, sha256]));
+    const afterHashes = new Map(after.map(({ path, sha256 }) => [path, sha256]));
+    const paths = [...new Set([...beforeHashes.keys(), ...afterHashes.keys()])];
+    return paths
+        .sort()
+        .map(path => ({
+        after: afterHashes.get(path) ?? null,
+        before: beforeHashes.get(path) ?? null,
+        path,
+    }))
+        .filter(({ after, before }) => after !== before);
+}
+// Shows the integrity where the version did not move, so a rebuild under the same version shows.
+function resolveInstalledVersionText(installedVersion, otherInstalledVersion) {
+    if (installedVersion === null) {
+        return 'none';
+    }
+    return installedVersion.version === otherInstalledVersion?.version
+        ? (installedVersion.integrity ?? 'no integrity')
+        : installedVersion.version;
+}

package/dist/commands/fingerprint.js

@@ -0,0 +1,42 @@
+import { computeFingerprint } from '@hotcodepush/protocol/fingerprint';
+import { defineCommand } from '../utils/command.js';
+import { readProjectFingerprintContributors } from '../utils/fingerprint.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson, printTable } from '../utils/output.js';
+import { locateProjectConfig } from '../utils/project-config.js';
+export default defineCommand({
+    description: "Print the project's native fingerprint with the packages and the files under the extra fingerprint paths that contribute to it. Runs locally without a login.",
+    authentication: 'optional',
+    examples: [
+        'hotcodepush fingerprint',
+        'hotcodepush fingerprint --json > fingerprint.json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const { directoryPath, projectConfig } = locateProjectConfig(options.config);
+        const contributors = await readProjectFingerprintContributors(directoryPath, projectConfig?.extraFingerprintPaths ?? []);
+        const fingerprint = computeFingerprint(contributors);
+        if (options.json) {
+            printJson({ fingerprint, ...contributors });
+            return;
+        }
+        console.log(`Fingerprint ${fingerprint}`);
+        printTable({
+            emptyText: 'No installed package ships native code.',
+            headers: ['PACKAGE', 'VERSION'],
+            nextOffset: null,
+            rows: contributors.packages.map(({ name, version }) => [name, version]),
+        });
+        if (contributors.extraFingerprintPaths.length > 0) {
+            printTable({
+                emptyText: '',
+                headers: ['EXTRA FINGERPRINT PATH', 'SHA-256'],
+                nextOffset: null,
+                rows: contributors.extraFingerprintPaths.map(({ path, sha256 }) => [
+                    path,
+                    sha256,
+                ]),
+            });
+        }
+    },
+});

package/dist/commands/init.js

@@ -0,0 +1,493 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { HotCodePushError } from '@hotcodepush/node';
+import { z } from 'zod';
+import { DOCS_URL, PROJECT_CONFIG_FILE_NAME, SIGNING_PRIVATE_KEY_FILE_NAME, } from '../config/consts.js';
+import { createApiClient } from '../utils/api-client.js';
+import { defineCommand } from '../utils/command.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 { logIn } from '../utils/login.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 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.',
+    authentication: 'optional',
+    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,
+    };
+}