hotcodepush 0.0.0 → 0.1.0

package/dist/utils/errors.js

@@ -0,0 +1,266 @@
+import { ISSUES_URL, PROJECT_CONFIG_FILE_NAME } from '../config/consts.js';
+export const ExitCode = {
+    ConfirmationRequired: 4,
+    Error: 1,
+    MissingOrInvalidParameter: 2,
+    NotLoggedIn: 3,
+    Success: 0,
+};
+export class CliError extends Error {
+    code;
+    exitCode;
+    fix;
+    constructor({ cause, code, exitCode, fix, message }) {
+        super(message, { cause });
+        this.code = code;
+        this.exitCode = exitCode;
+        this.fix = fix;
+        this.name = new.target.name;
+    }
+}
+// Organizations can share a name, and so can apps of different organizations.
+export class AmbiguousNameError extends CliError {
+    constructor(noun, name, source = `--${noun}`) {
+        super({
+            code: 'invalid_parameter',
+            exitCode: ExitCode.MissingOrInvalidParameter,
+            fix: `Pass the id instead, as "hotcodepush ${noun} list" prints it.`,
+            message: `Several ${noun}s carry the name "${name}" from ${source}.`,
+        });
+    }
+}
+// The message from the API carries its own fix.
+// A 401 means the token is no longer valid, so the exit code is 3.
+export class ApiError extends CliError {
+    constructor(code, message, status) {
+        super({
+            code,
+            exitCode: status === 401 ? ExitCode.NotLoggedIn : ExitCode.Error,
+            fix: null,
+            message,
+        });
+    }
+}
+// Checked before any upload, so no upload is wasted on a refusal from the API.
+export class BundleTooLargeError extends CliError {
+    constructor(what, bundleBytesLimit) {
+        super({
+            code: 'bundle_too_large',
+            exitCode: ExitCode.Error,
+            fix: 'A file or a bundle is at most 512 MB. Move large media out of the web build.',
+            message: `${what} is above the limit of ${bundleBytesLimit} bytes.`,
+        });
+    }
+}
+export class CommandFailedError extends CliError {
+    constructor(commandLine, exitCode) {
+        super({
+            code: 'command_failed',
+            exitCode: ExitCode.Error,
+            fix: 'Run it by hand and read its output.',
+            message: `The command "${commandLine}" exited with ${exitCode ?? 'a signal'}.`,
+        });
+    }
+}
+export class ConfirmationRequiredError extends CliError {
+    constructor(consequence, fix = 'Pass --yes to confirm.') {
+        super({
+            code: 'confirmation_required',
+            exitCode: ExitCode.ConfirmationRequired,
+            fix,
+            message: `A confirmation is required. This ${consequence}.`,
+        });
+    }
+}
+// A build without a fingerprint would match binaries it does not describe.
+// The fix is the message of the protocol package as it stands.
+export class FingerprintUnavailableError extends CliError {
+    constructor(cause) {
+        super({
+            cause,
+            code: 'fingerprint_unavailable',
+            exitCode: ExitCode.Error,
+            fix: cause.message,
+            message: 'The fingerprint cannot be computed.',
+        });
+    }
+}
+// Never names the file content, since `config.json` can hold the token.
+export class InvalidJsonError extends CliError {
+    constructor(filePath, problem) {
+        super({
+            code: 'invalid_json',
+            exitCode: ExitCode.Error,
+            fix: 'Correct the JSON in that file and run the command again.',
+            message: `The file ${filePath} is not valid JSON. ${problem}.`,
+        });
+    }
+}
+export class InvalidParameterError extends CliError {
+    constructor(message, fix = 'Run the command with --help to see its options.', cause) {
+        super({
+            cause,
+            code: 'invalid_parameter',
+            exitCode: ExitCode.MissingOrInvalidParameter,
+            fix,
+            message,
+        });
+    }
+}
+export class LoginDeniedError extends CliError {
+    constructor() {
+        super({
+            code: 'login_denied',
+            exitCode: ExitCode.Error,
+            fix: 'Run "hotcodepush login" again to approve it.',
+            message: 'The login was denied in the browser.',
+        });
+    }
+}
+export class LoginExpiredError extends CliError {
+    constructor() {
+        super({
+            code: 'login_expired',
+            exitCode: ExitCode.Error,
+            fix: 'Run "hotcodepush login" again and approve the code before it expires.',
+            message: 'The login code expired before it was approved.',
+        });
+    }
+}
+export class MissingParameterError extends CliError {
+    constructor(flag, fix = `Pass ${flag}, or run the command interactively to be asked for it.`) {
+        super({
+            code: 'missing_parameter',
+            exitCode: ExitCode.MissingOrInvalidParameter,
+            fix,
+            message: `No value was given for ${flag}.`,
+        });
+    }
+}
+export class NativeProjectError extends CliError {
+    constructor(message, fix) {
+        super({
+            code: 'native_project',
+            exitCode: ExitCode.Error,
+            fix,
+            message,
+        });
+    }
+}
+// From a login that cannot wait for the approval, the fix carries the page and the code for an agent to relay.
+export class NotLoggedInError extends CliError {
+    constructor(deviceAuthorizationPrompt) {
+        super({
+            code: 'not_logged_in',
+            exitCode: ExitCode.NotLoggedIn,
+            fix: deviceAuthorizationPrompt
+                ? `Approve at ${deviceAuthorizationPrompt.verificationUrl} with code ${deviceAuthorizationPrompt.userCode}, then run "hotcodepush login" again.`
+                : 'Run "hotcodepush login" or set HOTCODEPUSH_TOKEN.',
+            message: 'You are not logged in.',
+        });
+    }
+}
+// A shipped build must name its channel, so CI fails where a local build goes on offline.
+export class PipelineNotLoggedInError extends CliError {
+    constructor() {
+        super({
+            code: 'not_logged_in',
+            exitCode: ExitCode.NotLoggedIn,
+            fix: 'Set HOTCODEPUSH_TOKEN in the pipeline, or HOTCODEPUSH_OFFLINE=1 for a build that is never shipped.',
+            message: 'You are not logged in, and a build in CI must name its channel.',
+        });
+    }
+}
+// The command printed its outcome itself, so the entry point prints nothing more.
+// The stopped step of `init` goes into its telemetry event.
+export class ReportedFailureError extends CliError {
+    stoppedStep;
+    constructor(code, stoppedStep) {
+        super({
+            code,
+            exitCode: ExitCode.Error,
+            fix: null,
+            message: 'Reported above.',
+        });
+        this.stoppedStep = stoppedStep;
+    }
+}
+// The app accepts only signed bundles, so the upload stops before any byte moves.
+export class SigningKeyUnavailableError extends CliError {
+    constructor() {
+        super({
+            code: 'signing_key_unavailable',
+            exitCode: ExitCode.Error,
+            fix: 'Pass --private-key-path with the file "hotcodepush signing-key create" wrote, or set HOTCODEPUSH_SIGNING_KEY to its content.',
+            message: `No private key is given to sign with, and ${PROJECT_CONFIG_FILE_NAME} lists public keys.`,
+        });
+    }
+}
+export class UnexpectedError extends CliError {
+    constructor(cause) {
+        super({
+            cause,
+            code: 'unexpected',
+            exitCode: ExitCode.Error,
+            fix: `Run the command again with --verbose, and report it at ${ISSUES_URL} if it persists.`,
+            message: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+}
+// A proxy error page or a body without a catalog code.
+// The typed client keeps its error as the cause; the Better Auth client gives an error without a code.
+export class UnexpectedResponseError extends CliError {
+    constructor(status, cause) {
+        super({
+            cause,
+            code: 'unexpected_response',
+            exitCode: ExitCode.Error,
+            fix: `Check the API URL in config.json and the network, and report it at ${ISSUES_URL} if it persists.`,
+            message: `The API answered with status ${status} in an unexpected shape.`,
+        });
+    }
+}
+export class XcodeProjectError extends CliError {
+    constructor(message, cause, projectFilePath, fix = `Add the build phase to the app target in ${projectFilePath} by hand.`) {
+        super({
+            cause,
+            code: 'xcode_project',
+            exitCode: ExitCode.Error,
+            fix,
+            message,
+        });
+    }
+}
+export class UnknownFrameworkError extends CliError {
+    constructor() {
+        super({
+            code: 'unknown_framework',
+            exitCode: ExitCode.Error,
+            fix: 'Run it in a project with react-native, expo, @capacitor/core or cordova among its dependencies.',
+            message: 'No supported framework was found in package.json.',
+        });
+    }
+}
+export class UnknownCommandError extends CliError {
+    constructor(typedCommand, closestCommandName) {
+        super({
+            code: 'unknown_command',
+            exitCode: ExitCode.Error,
+            fix: closestCommandName
+                ? `Did you mean "${closestCommandName}"?`
+                : 'Run "hotcodepush --help" to list the commands.',
+            message: `There is no command "${typedCommand}".`,
+        });
+    }
+}
+// An unknown id is the API's own `not_found` instead.
+export class UnknownNameError extends CliError {
+    constructor(noun, name, source = `--${noun}`) {
+        super({
+            code: 'invalid_parameter',
+            exitCode: ExitCode.MissingOrInvalidParameter,
+            fix: `Run "hotcodepush ${noun} list" to see the names.`,
+            message: `The ${noun} "${name}" from ${source} does not exist.`,
+        });
+    }
+}

package/dist/utils/fingerprint.js

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile, realpath } from 'node:fs/promises';
+import { dirname, join, relative, sep } from 'node:path';
+import { computeFingerprint, FingerprintError, LOCKFILE_NAMES, readFingerprintContributors, } from '@hotcodepush/protocol/fingerprint';
+import { FingerprintUnavailableError } from './errors.js';
+// Errors for a path that holds nothing of the kind asked for.
+const ABSENT_ERROR_CODES = new Set(['EISDIR', 'ENOENT', 'ENOTDIR']);
+// The extra fingerprint paths are relative to the project root and may reach a sibling workspace through `..`.
+export async function readFingerprint(projectDirectoryPath, extraFingerprintPaths) {
+    return computeFingerprint(await readProjectFingerprintContributors(projectDirectoryPath, extraFingerprintPaths));
+}
+export function hasLockfile(projectDirectoryPath) {
+    return findLockfileDirectoryPath(projectDirectoryPath) !== undefined;
+}
+// The recipe reads from the nearest lockfile directory, which is the monorepo root where the workspace installs.
+// It resolves the extra paths against the project and refuses any outside that directory.
+export async function readProjectFingerprintContributors(projectDirectoryPath, extraFingerprintPaths) {
+    const lockfileDirectoryPath = findLockfileDirectoryPath(projectDirectoryPath) ?? projectDirectoryPath;
+    const projectPath = relative(lockfileDirectoryPath, projectDirectoryPath)
+        .split(sep)
+        .join('/');
+    try {
+        return await readFingerprintContributors({
+            extraFingerprintPaths,
+            projectPath,
+            reader: createProjectReader(lockfileDirectoryPath),
+        });
+    }
+    catch (error) {
+        if (error instanceof FingerprintError) {
+            throw new FingerprintUnavailableError(error);
+        }
+        throw error;
+    }
+}
+function findLockfileDirectoryPath(directoryPath) {
+    if (LOCKFILE_NAMES.some(fileName => existsSync(join(directoryPath, fileName)))) {
+        return directoryPath;
+    }
+    const parentDirectoryPath = dirname(directoryPath);
+    return parentDirectoryPath === directoryPath
+        ? undefined
+        : findLockfileDirectoryPath(parentDirectoryPath);
+}
+function createProjectReader(rootDirectoryPath) {
+    return {
+        readDirectory: path => readAbsentAsNull(async () => (await readdir(join(rootDirectoryPath, path), {
+            withFileTypes: true,
+        })).map(entry => ({
+            isDirectory: entry.isDirectory(),
+            name: entry.name,
+        }))),
+        readFile: path => readAbsentAsNull(() => readFile(join(rootDirectoryPath, path))),
+        readRealPath: path => readAbsentAsNull(async () => {
+            const [rootRealPath, targetRealPath] = await Promise.all([
+                realpath(rootDirectoryPath),
+                realpath(join(rootDirectoryPath, path)),
+            ]);
+            // A link out of the root yields a path starting with `..`, which the recipe refuses.
+            return relative(rootRealPath, targetRealPath).split(sep).join('/');
+        }),
+    };
+}
+async function readAbsentAsNull(read) {
+    try {
+        return await read();
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            ABSENT_ERROR_CODES.has(String(error.code))) {
+            return null;
+        }
+        throw error;
+    }
+}

package/dist/utils/flag-name.js

@@ -0,0 +1,4 @@
+// Matches how zodline maps a schema key to a flag: `rolloutPercent` becomes `rollout-percent`.
+export function resolveFlagName(key) {
+    return key.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+}

package/dist/utils/fleet.js

@@ -0,0 +1,9 @@
+// The fleet counts only the devices seen in the last 30 days.
+export const UNSEEN_IN_FLEET_WINDOW_TEXT = 'not in 30 days';
+export function resolveBinaryBucket(fleet, binaryId) {
+    return fleet.binary.find(({ value }) => value === binaryId);
+}
+// A null release id stands for the embedded bundles.
+export function resolveReleaseDeviceCount(fleet, releaseId) {
+    return (fleet.release.find(({ value }) => value === releaseId)?.deviceCount ?? 0);
+}

package/dist/utils/framework.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { isInteractive } from './environment.js';
+import { MissingParameterError, UnknownFrameworkError } from './errors.js';
+import { CAPACITOR_CONFIG_FILE_NAMES } from './frameworks/capacitor.js';
+import { readPackageJson } from './package-json.js';
+import { promptText } from './prompts.js';
+const FRAMEWORK_PACKAGES = [
+    ['@capacitor/core', 'capacitor'],
+    ['cordova', 'cordova'],
+    ['expo', 'expo'],
+    ['react-native', 'react_native'],
+];
+// An Expo app also depends on `react-native`, so the framework's config file breaks a tie.
+export function detectFramework(projectDirectoryPath) {
+    if (!existsSync(join(projectDirectoryPath, 'package.json'))) {
+        throw new UnknownFrameworkError();
+    }
+    const packageJson = readPackageJson(projectDirectoryPath);
+    const dependencyNames = new Set([
+        ...Object.keys(packageJson.dependencies ?? {}),
+        ...Object.keys(packageJson.devDependencies ?? {}),
+    ]);
+    const detectedFrameworks = FRAMEWORK_PACKAGES.filter(([packageName]) => dependencyNames.has(packageName)).map(([, framework]) => framework);
+    const framework = detectedFrameworks.find(detectedFramework => hasFrameworkConfigFile(detectedFramework, projectDirectoryPath)) ?? detectedFrameworks[0];
+    if (framework === undefined) {
+        throw new UnknownFrameworkError();
+    }
+    return framework;
+}
+export async function resolveInputDirectoryPath(options, pathFlag, projectDirectoryPath, framework) {
+    if (options.path !== undefined) {
+        return resolve(options.path);
+    }
+    const buildDirectory = framework.readBuildDirectory(projectDirectoryPath);
+    if ('path' in buildDirectory) {
+        return join(projectDirectoryPath, buildDirectory.path);
+    }
+    if (!isInteractive(options)) {
+        throw new MissingParameterError(pathFlag, `Pass ${pathFlag}, since ${buildDirectory.missingReason}.`);
+    }
+    return resolve(await promptText(pathFlag, 'Where is the web build?', options));
+}
+export function assertMissingParameter(value, flag) {
+    if (value === undefined) {
+        throw new MissingParameterError(flag);
+    }
+    return value;
+}
+function hasFrameworkConfigFile(framework, projectDirectoryPath) {
+    switch (framework) {
+        case 'capacitor':
+            return CAPACITOR_CONFIG_FILE_NAMES.some(fileName => existsSync(join(projectDirectoryPath, fileName)));
+        case 'cordova':
+            return existsSync(join(projectDirectoryPath, 'config.xml'));
+        case 'expo':
+            return hasExpoAppJson(projectDirectoryPath);
+        case 'react_native':
+            return false;
+    }
+}
+function hasExpoAppJson(projectDirectoryPath) {
+    const appJsonPath = join(projectDirectoryPath, 'app.json');
+    if (!existsSync(appJsonPath)) {
+        return false;
+    }
+    try {
+        const appJson = JSON.parse(readFileSync(appJsonPath, 'utf8'));
+        return typeof appJson === 'object' && appJson !== null && 'expo' in appJson;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/frameworks/binary-create-step.js

@@ -0,0 +1,70 @@
+import { relative } from 'node:path';
+import { INIT_MANUAL_STEP } from '../../config/consts.js';
+import { NativeProjectError, XcodeProjectError } from '../errors.js';
+import { resolveGradleEdit } from '../native-project-edit.js';
+import { addBinaryCreatePhase, hasBinaryCreatePhase, resolveXcodeProjectFilePath, } from '../xcode-project.js';
+export function checkBinaryCreateStep(projectDirectoryPath, nativeProjectPaths, packageName) {
+    const xcodeProjectFilePath = resolveXcodeProjectFilePath(nativeProjectPaths.ios);
+    const gradleEdit = resolveGradleEdit(nativeProjectPaths.android, packageName);
+    return checkEdits('hook', 'The Xcode phase and the Gradle task run the build step.', gradleEdit === undefined ? [] : [gradleEdit], projectDirectoryPath, xcodeProjectFilePath !== undefined &&
+        !hasBinaryCreatePhase(xcodeProjectFilePath));
+}
+export function checkEdits(check, wiredMessage, edits, projectDirectoryPath, isPhaseMissing = false) {
+    const missingFilePaths = edits
+        .filter(edit => !edit.isApplied())
+        .map(({ filePath }) => relative(projectDirectoryPath, filePath));
+    if (edits.length === 0 && !isPhaseMissing) {
+        return {
+            check,
+            message: 'There is no native project to check.',
+            status: 'skipped',
+        };
+    }
+    if (missingFilePaths.length > 0 || isPhaseMissing) {
+        return {
+            check,
+            code: 'wiring_missing',
+            manualStep: INIT_MANUAL_STEP,
+            message: `The wiring is missing from ${[...(isPhaseMissing ? ['the Xcode project'] : []), ...missingFilePaths].join(' and ')}.`,
+            status: 'failed',
+        };
+    }
+    return { check, message: wiredMessage, status: 'ok' };
+}
+// A failed edit does not hold the others back. Once all were tried, the first failure stops the step.
+export async function applyNativeProjectEdits(phaseEdit, edits, options) {
+    const errors = [];
+    const wired = [];
+    if (phaseEdit !== undefined) {
+        try {
+            if ((await addBinaryCreatePhase(phaseEdit.projectFilePath, phaseEdit.phase, options)) === 'added') {
+                wired.push('the Create HotCodePush binary phase in Xcode');
+            }
+        }
+        catch (error) {
+            errors.push(assertEditError(error));
+        }
+    }
+    for (const edit of edits) {
+        try {
+            edit.apply();
+            wired.push(edit.description);
+        }
+        catch (error) {
+            errors.push(assertEditError(error));
+        }
+    }
+    const [firstError] = errors;
+    if (firstError !== undefined) {
+        throw firstError;
+    }
+    return wired;
+}
+// Only an edit that found no place in its file becomes the manual step. Any other error is rethrown.
+function assertEditError(error) {
+    if (error instanceof NativeProjectError ||
+        error instanceof XcodeProjectError) {
+        return error;
+    }
+    throw error;
+}

package/dist/utils/frameworks/capacitor.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+import { CAPACITOR_PACKAGE_NAME, CAPACITOR_PACKAGE_SPEC, } from '../../config/consts.js';
+import { resolveGradleEdit } from '../native-project-edit.js';
+import { buildPbxprojShellScript, hasBinaryCreatePhase, hasReadableResourceReference, removeResourceReference, resolveXcodeProjectFilePath, } from '../xcode-project.js';
+import { applyNativeProjectEdits, checkBinaryCreateStep, } from './binary-create-step.js';
+import { NATIVE_GLUE_PATHS } from './native-glue.js';
+import { resolveNativeProjects } from './native-projects.js';
+import { checkSdkPackage, installSdkPackage, isSdkPackageDeclared, } from './sdk-package.js';
+const BINARY_CREATE_SCRIPT_PATH = `node_modules/${CAPACITOR_PACKAGE_NAME}/scripts/binary-create-xcode.sh`;
+export const CAPACITOR_CONFIG_FILE_NAMES = [
+    'capacitor.config.json',
+    'capacitor.config.ts',
+];
+export const capacitorFramework = {
+    nativeGluePaths: NATIVE_GLUE_PATHS,
+    packageName: CAPACITOR_PACKAGE_NAME,
+    versionedPackageNames: ['@capacitor/core', CAPACITOR_PACKAGE_NAME],
+    checkWiring: project => [
+        checkSdkPackage(project, CAPACITOR_PACKAGE_NAME),
+        checkBinaryCreateStep(project.directoryPath, resolveNativeProjectPaths(project.directoryPath), CAPACITOR_PACKAGE_NAME),
+    ],
+    readBuildDirectory: readWebDir,
+    resolveWiring,
+};
+function readCapacitorConfig(projectDirectoryPath) {
+    for (const fileName of CAPACITOR_CONFIG_FILE_NAMES) {
+        const filePath = join(projectDirectoryPath, fileName);
+        if (existsSync(filePath)) {
+            return { fileName, text: readFileSync(filePath, 'utf8') };
+        }
+    }
+    return undefined;
+}
+function readConfigValue(capacitorConfig, pattern) {
+    return capacitorConfig === undefined
+        ? undefined
+        : pattern.exec(capacitorConfig.text)?.[1];
+}
+function readWebDir(projectDirectoryPath) {
+    const capacitorConfig = readCapacitorConfig(projectDirectoryPath);
+    if (capacitorConfig === undefined) {
+        return {
+            missingReason: `there is no ${CAPACITOR_CONFIG_FILE_NAMES.join(' or ')} to read webDir from`,
+        };
+    }
+    const webDir = readConfigValue(capacitorConfig, /webDir['"]?\s*:\s*['"]([^'"]+)['"]/);
+    return webDir === undefined
+        ? {
+            missingReason: `${capacitorConfig.fileName} sets no webDir the CLI can read as a quoted string`,
+        }
+        : { path: webDir };
+}
+function resolveNativeProjectPaths(projectDirectoryPath) {
+    const capacitorConfig = readCapacitorConfig(projectDirectoryPath);
+    return {
+        android: join(projectDirectoryPath, readConfigValue(capacitorConfig, /android:\s*\{[^}]*?path:\s*['"]([^'"]+)['"]/) ?? 'android'),
+        ios: join(projectDirectoryPath, readConfigValue(capacitorConfig, /ios:\s*\{[^}]*?path:\s*['"]([^'"]+)['"]/) ?? 'ios'),
+    };
+}
+// The phase runs last, once the web build is copied into the app. The script finds Node itself.
+function resolveBinaryCreatePhase(projectDirectoryPath, xcodeProjectFilePath) {
+    const projectRootPath = relative(dirname(dirname(xcodeProjectFilePath)), projectDirectoryPath)
+        .split(sep)
+        .join('/');
+    return {
+        anchorPhaseName: undefined,
+        fix: `Add a Run Script phase after the app target's last phase that runs ${BINARY_CREATE_SCRIPT_PATH}.`,
+        shellScript: buildPbxprojShellScript([
+            'set -e',
+            '',
+            '# hotcodepush: writes hotcodepush.json into the app and, in a store build, creates the binary',
+            `PROJECT_ROOT="$PROJECT_DIR${projectRootPath === '' ? '' : `/${projectRootPath}`}"`,
+            'export PROJECT_ROOT',
+            `/bin/sh "$PROJECT_ROOT/${BINARY_CREATE_SCRIPT_PATH}"`,
+            '',
+        ]),
+    };
+}
+async function resolveWiring({ directoryPath, packageJson }, options) {
+    const nativeProjects = await resolveNativeProjects(directoryPath, resolveNativeProjectPaths(directoryPath), options, 'Run "npx cap add ios" and "npx cap add android", or pass --ios-path and --android-path.');
+    const xcodeProjectFilePath = resolveXcodeProjectFilePath(nativeProjects.ios);
+    const isPackageInstalled = isSdkPackageDeclared(packageJson, CAPACITOR_PACKAGE_NAME);
+    return {
+        isPackageInstalled,
+        nativeFilePaths: [
+            ...new Set([
+                ...(xcodeProjectFilePath === undefined ||
+                    hasBinaryCreatePhase(xcodeProjectFilePath)
+                    ? []
+                    : [xcodeProjectFilePath]),
+                ...resolvePendingEdits(nativeProjects, xcodeProjectFilePath)
+                    .filter(edit => !edit.isRefused)
+                    .map(({ filePath }) => filePath),
+            ]),
+        ].map(filePath => relative(directoryPath, filePath)),
+        packageFilePaths: isPackageInstalled ? [] : ['package.json'],
+        installPackage: () => installSdkPackage(directoryPath, CAPACITOR_PACKAGE_NAME, CAPACITOR_PACKAGE_SPEC),
+        wireBinaryCreateStep: editBlocker => wireBinaryCreateStep(directoryPath, nativeProjects, xcodeProjectFilePath, editBlocker, options),
+    };
+}
+function resolvePendingEdits(nativeProjectPaths, xcodeProjectFilePath) {
+    return [
+        xcodeProjectFilePath === undefined
+            ? undefined
+            : resolveResourceReferenceEdit(xcodeProjectFilePath),
+        resolveGradleEdit(nativeProjectPaths.android, CAPACITOR_PACKAGE_NAME),
+    ]
+        .filter(edit => edit !== undefined)
+        .filter(edit => !edit.isApplied());
+}
+function resolveResourceReferenceEdit(xcodeProjectFilePath) {
+    return {
+        description: 'the Xcode project without its hotcodepush.json reference',
+        filePath: xcodeProjectFilePath,
+        isApplied: () => !hasReadableResourceReference(xcodeProjectFilePath),
+        apply: () => {
+            removeResourceReference(xcodeProjectFilePath);
+        },
+    };
+}
+async function wireBinaryCreateStep(projectDirectoryPath, nativeProjects, xcodeProjectFilePath, editBlocker, options) {
+    if (nativeProjects.missingError !== undefined) {
+        throw nativeProjects.missingError;
+    }
+    const isPhaseWired = xcodeProjectFilePath === undefined ||
+        hasBinaryCreatePhase(xcodeProjectFilePath);
+    const pendingEdits = resolvePendingEdits(nativeProjects, xcodeProjectFilePath);
+    if (isPhaseWired && pendingEdits.length === 0) {
+        return {
+            message: 'The Xcode phase and the Gradle task are already wired.',
+            status: 'skipped',
+            value: undefined,
+        };
+    }
+    if (editBlocker !== undefined) {
+        throw editBlocker;
+    }
+    const wired = await applyNativeProjectEdits(xcodeProjectFilePath === undefined
+        ? undefined
+        : {
+            phase: resolveBinaryCreatePhase(projectDirectoryPath, xcodeProjectFilePath),
+            projectFilePath: xcodeProjectFilePath,
+        }, pendingEdits, options);
+    return {
+        message: `Wired ${wired.join(', ')}.`,
+        status: 'done',
+        value: undefined,
+    };
+}