hotcodepush 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Genz IT Solutions GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# hotcodepush
+
+The HotCodePush CLI: set up, release and manage over-the-air (OTA) updates for React Native, Expo, Capacitor and Cordova apps from the terminal and CI.
+
+## Installation
+
+The CLI is not on npm yet. Install the preview build of a commit on `main` as a dev dependency, `<sha>` being the commit's short hash:
+
+```sh
+npm install --save-dev https://pkg.pr.new/hotcodepush-team/cli/hotcodepush@<sha>
+```
+
+## Usage
+
+```sh
+npx hotcodepush login
+npx hotcodepush init                                  # wires the SDK and the build step into your project
+npx hotcodepush release create --path dist            # uploads the build and releases it to the project's channel
+npx hotcodepush release create --channel staging --rollout-percent 10
+npx hotcodepush doctor                                # checks the setup
+npx hotcodepush --help                                # every command; <command> --help for its flags
+```
+
+Every command takes `--json` for machine-readable output and `--yes` to skip confirmations.
+In CI, set `HOTCODEPUSH_TOKEN` instead of logging in, and `HOTCODEPUSH_API_BASE_URL` when the token belongs to an API other than production.
+
+### Telemetry
+
+After each command, the CLI sends one anonymous event (`command`, `outcome`, `stopped_step` for `init`, `duration_ms`, `cli_version`, `is_ci`, `framework` and `source`) to PostHog, and unexpected errors without their message to Sentry.
+No argument, path or name from your project is ever sent.
+Set `HOTCODEPUSH_TELEMETRY_DISABLED=1` or `DO_NOT_TRACK=1` to turn it off.
+
+## Documentation
+
+See [hotcodepush.com/docs/cli](https://hotcodepush.com/docs/cli).
+
+## Development
+
+```sh
+nvm use
+npm ci
+npm run build        # compiles src/ into dist/; node dist/index.js --help runs it
+npm test
+npm run lint && npm run typecheck
+npm run fmt          # Prettier, run before every commit
+```
+
+Tests live next to the code they test as `*.test.ts`.
+`CLAUDE.md` holds the layout, the rules and how to add a command or a framework.
+
+## License
+
+See [LICENSE](./LICENSE).

package/dist/commands/app/create.js

@@ -0,0 +1,49 @@
+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 { promptSelect, promptText } from '../../utils/prompts.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+const FRAMEWORKS = [
+    'react_native',
+    'expo',
+    'capacitor',
+    'cordova',
+];
+export default defineCommand({
+    description: 'Create an app with its default channel, production.',
+    examples: [
+        'hotcodepush app create --name "My App" --framework capacitor',
+        'hotcodepush app create --organization Acme --name "My App" --framework expo --json',
+    ],
+    options: defineCommandOptions({
+        framework: z
+            .enum(FRAMEWORKS)
+            .optional()
+            .describe('The framework: react_native, expo, capacitor or cordova.'),
+        name: z
+            .string()
+            .optional()
+            .describe("The app's name, unique in the organization."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        const name = options.name ??
+            (await promptText('--name', 'What is the app called?', options));
+        const framework = options.framework ??
+            (await promptSelect('--framework', 'Which framework does the app use?', FRAMEWORKS.map(framework => ({ label: framework, value: framework })), options));
+        const createdApp = await hotCodePush.organizations.apps.create({
+            framework,
+            name,
+            organizationId,
+        });
+        if (options.json) {
+            printJson(createdApp);
+        }
+        else {
+            console.log(`Created app ${createdApp.name} (${createdApp.id}).`);
+        }
+    },
+});

package/dist/commands/app/delete.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, resolveQuantityText } from '../../utils/output.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchAppId, fetchChannels } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Delete an app with its channels, bundles and releases; support can restore it for seven days.',
+    examples: [
+        'hotcodepush app delete --app "My App"',
+        'hotcodepush app delete --app 7c9e6679-7425-40de-944b-e07fc1f90ae7 --yes --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const [fetchedApp, fetchedChannels] = await Promise.all([
+            hotCodePush.apps.get({ appId }),
+            fetchChannels(hotCodePush, appId),
+        ]);
+        const isConfirmed = await confirmConsequence(`deletes app ${fetchedApp.name} and its ${resolveQuantityText(fetchedChannels.length, 'channel')}`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.apps.delete({ appId });
+        if (options.json) {
+            printJson({ id: appId, name: fetchedApp.name });
+        }
+        else {
+            console.log(`Deleted app ${fetchedApp.name} (${appId}).`);
+        }
+    },
+});

package/dist/commands/app/get.js

@@ -0,0 +1,33 @@
+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 { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Print an app, hotcodepush.json's by default.",
+    examples: [
+        'hotcodepush app get',
+        'hotcodepush app get --app "My App" --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedApp = await hotCodePush.apps.get({
+            appId: await fetchAppId(hotCodePush, options, readProjectConfig(options.config)),
+        });
+        if (options.json) {
+            printJson(fetchedApp);
+            return;
+        }
+        printDetails([
+            ['ID', fetchedApp.id],
+            ['Name', fetchedApp.name],
+            ['Framework', fetchedApp.framework],
+            ['Organization', fetchedApp.organizationId],
+            ['Default channel', fetchedApp.defaultChannelId ?? 'none'],
+            ['Channel link template', fetchedApp.channelLinkTemplate ?? 'none'],
+            ['Created', fetchedApp.createdAt],
+        ]);
+    },
+});

package/dist/commands/app/list.js

@@ -0,0 +1,38 @@
+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 an organization's apps, newest first.",
+    examples: [
+        'hotcodepush app list',
+        'hotcodepush app list --organization Acme --json',
+    ],
+    options: defineCommandOptions(paginationShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const listedApps = await hotCodePush.organizations.apps.list({
+            limit: options.limit,
+            offset: options.offset,
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        const nextOffset = resolveNextOffset(listedApps.length, options);
+        if (options.json) {
+            printJson({ apps: listedApps, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No apps.',
+            headers: ['ID', 'NAME', 'FRAMEWORK', 'CREATED'],
+            nextOffset,
+            rows: listedApps.map(({ createdAt, framework, id, name }) => [
+                id,
+                name,
+                framework,
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/app/transfer.js

@@ -0,0 +1,58 @@
+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 { readProjectConfig } from '../../utils/project-config.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { fetchAppId, fetchOrganizations, fetchResourceId, promptResourceId, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Move an app to the organization --organization names, one you are an Admin of.',
+    examples: [
+        'hotcodepush app transfer --organization Globex',
+        'hotcodepush app transfer --app "My App" --organization Globex --yes --json',
+    ],
+    options: defineCommandOptions({
+        organization: z
+            .string()
+            .optional()
+            .describe('The organization the app moves to, by id or name.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        // Here `--organization` names the target, so the app name is looked up in every organization of the user.
+        const appId = await fetchAppId(hotCodePush, { ...options, organization: undefined }, readProjectConfig(options.config));
+        const [fetchedApp, fetchedOrganizations] = await Promise.all([
+            hotCodePush.apps.get({ appId }),
+            fetchOrganizations(hotCodePush),
+        ]);
+        const targetOrganizationId = await pickTargetOrganizationId(fetchedApp, fetchedOrganizations, options);
+        const sourceOrganizationName = resolveOrganizationName(fetchedOrganizations, fetchedApp.organizationId);
+        const targetOrganizationName = resolveOrganizationName(fetchedOrganizations, targetOrganizationId);
+        const isConfirmed = await confirmConsequence(`moves app ${fetchedApp.name} from organization ${sourceOrganizationName} to organization ${targetOrganizationName}`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const transferredApp = await hotCodePush.apps.transfer({
+            appId,
+            organizationId: targetOrganizationId,
+        });
+        if (options.json) {
+            printJson(transferredApp);
+        }
+        else {
+            console.log(`Transferred app ${transferredApp.name} (${transferredApp.id}) to organization ${targetOrganizationName}.`);
+        }
+    },
+});
+function pickTargetOrganizationId(app, organizations, options) {
+    if (options.organization === undefined) {
+        return promptResourceId('organization', organizations.filter(({ id }) => id !== app.organizationId), options);
+    }
+    return fetchResourceId('organization', options.organization, async () => organizations);
+}
+// Falls back to the id when the organizations of the user do not include it.
+function resolveOrganizationName(organizations, organizationId) {
+    return (organizations.find(({ id }) => id === organizationId)?.name ??
+        organizationId);
+}

package/dist/commands/app/update.js

@@ -0,0 +1,34 @@
+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 { readProjectConfig } from '../../utils/project-config.js';
+import { promptText } from '../../utils/prompts.js';
+import { fetchAppId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Rename an app, hotcodepush.json's by default.",
+    examples: [
+        'hotcodepush app update --name "My New App"',
+        'hotcodepush app update --app "My App" --name "My New App" --json',
+    ],
+    options: defineCommandOptions({
+        name: z
+            .string()
+            .optional()
+            .describe("The app's new name, unique in the organization."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const name = options.name ??
+            (await promptText('--name', 'What is the app called now?', options));
+        const updatedApp = await hotCodePush.apps.update({ appId, name });
+        if (options.json) {
+            printJson(updatedApp);
+        }
+        else {
+            console.log(`Updated app ${updatedApp.name} (${updatedApp.id}).`);
+        }
+    },
+});

package/dist/commands/audience/get.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveAudienceText } from '../../utils/audience.js';
+import { hasLockfile, readFingerprint } from '../../utils/fingerprint.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable, printWarnings } from '../../utils/output.js';
+import { locateProjectConfig } from '../../utils/project-config.js';
+import { buildAudienceQuery, conditionOptionShape, } from '../../utils/release-conditions.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Preview the devices a release's conditions would reach in a channel, before it exists, the project's fingerprint among them; what release create --dry-run prints.",
+    examples: [
+        'hotcodepush audience get --binary-version ">=2.3.0" --rollout-percent 10',
+        'hotcodepush audience get --channel production --attribute tier=beta --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...conditionOptionShape,
+        rolloutPercent: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe('The rollout percentage to estimate, 0 to 100; 100 by default.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const channel = await fetchChannel(hotCodePush, options);
+        const rolloutPercent = options.rolloutPercent ?? 100;
+        const audience = await hotCodePush.apps.channels.audience.get({
+            ...buildAudienceQuery(options, await readProjectFingerprint(options.config), rolloutPercent),
+            appId: channel.appId,
+            channelId: channel.id,
+        });
+        printWarnings(audience.warnings);
+        if (options.json) {
+            printJson(audience);
+            return;
+        }
+        const audienceText = resolveAudienceText(audience, channel.name, rolloutPercent);
+        console.log(`${audienceText.charAt(0).toUpperCase()}${audienceText.slice(1)}.`);
+        if (audience.reachedDeviceCount === 0) {
+            return;
+        }
+        for (const [header, deviceCounts] of [
+            ['PLATFORM', audience.platform],
+            ['BINARY VERSION', audience.binaryVersion],
+        ]) {
+            printTable({
+                emptyText: '',
+                headers: [header, 'DEVICES'],
+                nextOffset: null,
+                rows: deviceCounts.map(({ deviceCount, value }) => [
+                    value ?? 'none',
+                    String(deviceCount),
+                ]),
+            });
+        }
+    },
+});
+// Uses the fingerprint that `release create` would set, so the preview counts the same devices.
+async function readProjectFingerprint(configPath) {
+    const { directoryPath, projectConfig } = locateProjectConfig(configPath);
+    return hasLockfile(directoryPath)
+        ? readFingerprint(directoryPath, projectConfig?.extraFingerprintPaths ?? [])
+        : null;
+}

package/dist/commands/audit-log/list.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveTimeBound } from '../../utils/duration.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { fetchApps, fetchOrganizationId, fetchResourceId, } from '../../utils/resource-resolution.js';
+const ACTOR_TYPES = ['system', 'user'];
+export default defineCommand({
+    description: "List the organization's audit log, newest first, filtered by type, actor, app and time, on a plan that includes the audit log.",
+    examples: [
+        'hotcodepush audit-log list --type "channel.*" --created-since 7d',
+        'hotcodepush audit-log list --app "My App" --actor 4f2c8a1e-6b3d-4e9f-a7c5-2d8b1e6f3a90 --json',
+    ],
+    options: defineCommandOptions({
+        ...paginationShape,
+        actor: z.string().optional().describe('The user who acted, by id.'),
+        actorType: z
+            .enum(ACTOR_TYPES)
+            .optional()
+            .describe('system for the rows no user wrote, user for the rest.'),
+        app: z
+            .string()
+            .optional()
+            .describe("The app, by id or name, to narrow the log to; the whole organization by default, never hotcodepush.json's app."),
+        createdSince: z
+            .string()
+            .optional()
+            .describe('The earliest row, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        createdUntil: z
+            .string()
+            .optional()
+            .describe('The latest row, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        type: z
+            .string()
+            .optional()
+            .describe('The type, such as channel.created, or channel.* for every action on the object.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const organizationId = await fetchOrganizationId(hotCodePush, options);
+        // The log belongs to the organization, so only `--app` filters it, never the app in hotcodepush.json.
+        const listedAuditLogs = await hotCodePush.organizations.auditLogs.list({
+            actorType: options.actorType,
+            appId: options.app === undefined
+                ? undefined
+                : await fetchResourceId('app', options.app, () => fetchApps(hotCodePush, organizationId)),
+            createdSince: resolveTimeBound(options.createdSince),
+            createdUntil: resolveTimeBound(options.createdUntil),
+            limit: options.limit,
+            offset: options.offset,
+            organizationId,
+            relations: ['user'],
+            type: options.type,
+            userId: options.actor,
+        });
+        const nextOffset = resolveNextOffset(listedAuditLogs.length, options);
+        if (options.json) {
+            printJson({ auditLogs: listedAuditLogs, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No audit log rows match.',
+            headers: ['TIME', 'TYPE', 'ACTOR', 'OBJECT'],
+            nextOffset,
+            rows: listedAuditLogs.map(auditLog => [
+                auditLog.createdAt,
+                auditLog.type,
+                resolveActorText(auditLog),
+                auditLog.objectId ?? '',
+            ]),
+        });
+    },
+});
+// Matches the console: the email while the user exists, the id after.
+function resolveActorText({ actorType, user, userId }) {
+    if (actorType === 'system') {
+        return 'System';
+    }
+    return user?.email ?? userId ?? '';
+}

package/dist/commands/binary/create.js

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { buildStepShape, fetchChannelId, readBuildStep, resolveChannelIdByShape, resolveFailureText, resolveOfflineCause, writeBuildResourceFile, } from '../../utils/build-step.js';
+import { compressFiles, withTemporaryDirectory, } from '../../utils/compressed-files.js';
+import { isCi } from '../../utils/environment.js';
+import { CliError, PipelineNotLoggedInError } from '../../utils/errors.js';
+import { assertMissingParameter } from '../../utils/framework.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { createReporter, resolveByteText } from '../../utils/progress.js';
+import { assertWithinBundleBytesLimit, resolveMissingSha256s, uploadMissingFiles, } from '../../utils/upload.js';
+const NO_UPLOAD = { fileCount: 0, sizeBytes: 0 };
+export default defineCommand({
+    description: 'The build step of a store build: creates the binary with the embedded bundle it ships and writes the resource file the SDK reads, naming that bundle; every other build runs resource-file write. HOTCODEPUSH_OFFLINE=1 builds without the API, naming no channel unless it is given by id and creating no binary.',
+    examples: [
+        'hotcodepush binary create --platform ios --embedded-bundle-path build/App.app/public --resource-file-path build/App.app/hotcodepush.json --binary-version 2.4.1 --binary-build 57',
+        'hotcodepush binary create --platform android --embedded-bundle-path build/assets/public --resource-file-path build/assets/hotcodepush.json --binary-version 2.4.1 --binary-build 57 --force',
+    ],
+    options: defineCommandOptions({
+        ...buildStepShape,
+        binaryBuild: z
+            .string()
+            .optional()
+            .describe("The store build's build number, from the build's variables."),
+        binaryVersion: z
+            .string()
+            .optional()
+            .describe("The store build's version, from the build's variables."),
+        force: z
+            .boolean()
+            .optional()
+            .describe('Replace a binary whose fingerprint conflicts, for the deliberate pre-ship rebuild.'),
+    }),
+    action: async (options) => {
+        const buildStep = await readBuildStep(options);
+        const { embeddedFiles, platform, resourceFilePath } = buildStep;
+        if (embeddedFiles === undefined) {
+            writeBuildResourceFile(buildStep, resolveChannelIdByShape(buildStep.channelReference), null);
+            process.stderr.write(`No binary created: the ${platform} build bundled no JavaScript, as a debug build served by the development server does. Wrote ${resourceFilePath} without an embedded bundle: over-the-air (OTA) updates are off in this build.\n`);
+            if (options.json) {
+                printJson({ binary: null, resourceFilePath, upload: NO_UPLOAD });
+            }
+            return;
+        }
+        assertWithinBundleBytesLimit(embeddedFiles);
+        const identity = resolveBinaryIdentity(options);
+        const binaryCreation = await createBuildBinary({
+            ...identity,
+            appId: buildStep.projectConfig.appId,
+            fingerprint: buildStep.fingerprint,
+            force: options.force ?? false,
+            platform,
+        }, buildStep, embeddedFiles, createReporter(options));
+        writeBuildResourceFile(buildStep, binaryCreation.channelId, {
+            bundleVersion: identity.binaryVersion,
+            files: embeddedFiles,
+            id: binaryCreation.binary?.bundleId ?? null,
+        });
+        if (binaryCreation.pipelineFailure !== undefined) {
+            throw binaryCreation.pipelineFailure;
+        }
+        if (binaryCreation.skippedReason !== null) {
+            process.stderr.write(`Warning: ${binaryCreation.skippedReason}\n`);
+        }
+        if (options.json) {
+            printJson({
+                binary: binaryCreation.binary,
+                resourceFilePath,
+                upload: binaryCreation.upload,
+            });
+            return;
+        }
+        console.log(`Wrote ${resourceFilePath} for ${platform}.`);
+        if (binaryCreation.binary !== null) {
+            console.log(`Created the binary ${platform} ${identity.binaryVersion} (${identity.binaryBuild}): ${binaryCreation.upload.fileCount} files uploaded, ${resolveByteText(binaryCreation.upload.sizeBytes)}.`);
+        }
+    },
+});
+async function createBuildBinary(request, buildStep, files, reporter) {
+    const channelIdByShape = resolveChannelIdByShape(buildStep.channelReference);
+    const offlineCause = resolveOfflineCause();
+    if (offlineCause === 'no-token' && isCi()) {
+        return resolveFailedCreation(channelIdByShape, new PipelineNotLoggedInError());
+    }
+    if (offlineCause !== undefined) {
+        return {
+            binary: null,
+            channelId: channelIdByShape,
+            skippedReason: resolveOfflineText(offlineCause, channelIdByShape),
+            upload: NO_UPLOAD,
+        };
+    }
+    const hotCodePush = createApiClient();
+    let channelId;
+    try {
+        channelId =
+            channelIdByShape ?? (await fetchChannelId(hotCodePush, buildStep));
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        if (isCi()) {
+            return resolveFailedCreation(null, error);
+        }
+        return {
+            binary: null,
+            channelId: null,
+            skippedReason: `the channel could not be resolved, so the build names none and takes no OTA updates, and no binary was created: ${resolveFailureText(error)}`,
+            upload: NO_UPLOAD,
+        };
+    }
+    try {
+        return {
+            ...(await createBinaryWithUploads(hotCodePush, request, files, reporter)),
+            channelId,
+            skippedReason: null,
+        };
+    }
+    catch (error) {
+        // A local build never breaks: a failed creation is one warning. CI fails with it, since what it ships must name its channel.
+        if (isCi()) {
+            return resolveFailedCreation(channelId, error);
+        }
+        return {
+            binary: null,
+            channelId,
+            skippedReason: `the binary was not created: ${resolveFailureText(error)}`,
+            upload: NO_UPLOAD,
+        };
+    }
+}
+async function createBinaryWithUploads(hotCodePush, request, files, reporter) {
+    const { binaryBuild, binaryVersion, ...identityless } = request;
+    const createOptions = {
+        ...identityless,
+        build: binaryBuild,
+        files: files.map(({ path, sha256, sizeBytes }) => ({
+            path,
+            sha256,
+            sizeBytes,
+        })),
+        version: binaryVersion,
+    };
+    try {
+        const binary = await hotCodePush.apps.binaries.create(createOptions);
+        return { binary, upload: NO_UPLOAD };
+    }
+    catch (error) {
+        const missingSha256s = resolveMissingSha256s(error);
+        if (missingSha256s === undefined) {
+            throw error;
+        }
+        reporter.report(`Uploading ${missingSha256s.length} files the app lacks…`);
+        const uploadedFiles = await withTemporaryDirectory(async (temporaryDirectoryPath) => uploadMissingFiles(hotCodePush, request.appId, missingSha256s, await compressFiles(files.filter(({ sha256 }) => missingSha256s.includes(sha256)), temporaryDirectoryPath), reporter));
+        const binary = await hotCodePush.apps.binaries.create(createOptions);
+        return { binary, upload: uploadedFiles };
+    }
+}
+// The CLI reads no project file for the identity.
+function resolveBinaryIdentity(options) {
+    const binaryVersion = assertMissingParameter(options.binaryVersion, '--binary-version');
+    return {
+        binaryBuild: assertMissingParameter(options.binaryBuild, '--binary-build'),
+        binaryVersion,
+    };
+}
+function resolveFailedCreation(channelId, pipelineFailure) {
+    return {
+        binary: null,
+        channelId,
+        pipelineFailure,
+        skippedReason: null,
+        upload: NO_UPLOAD,
+    };
+}
+function resolveOfflineText(offlineCause, channelId) {
+    const causeText = offlineCause === 'offline-switch'
+        ? 'HOTCODEPUSH_OFFLINE is set'
+        : 'not logged in';
+    const consequenceText = channelId === null
+        ? ': it names no channel and takes no OTA updates until it is built with a token, and no binary was created'
+        : ' and no binary was created';
+    const fixText = offlineCause === 'offline-switch'
+        ? ''
+        : '; run "hotcodepush login" or set HOTCODEPUSH_TOKEN';
+    return `${causeText}, so the build was made offline${consequenceText}${fixText}.`;
+}