@expo/repack-app 0.0.1

package/build/android/Resources.types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Types mapped from the Resoruces.proto file.
+ */
+export interface XmlNode {
+    element?: XmlElement;
+    text?: string;
+    source: SourcePosition;
+}
+export interface XmlElement {
+    namespaceDeclaration: XmlNamespace[];
+    namespaceUri: string;
+    name: string;
+    attribute: XmlAttribute[];
+    child: XmlNode[];
+}
+export interface XmlNamespace {
+    prefix: string;
+    uri: string;
+    source: SourcePosition;
+}
+export interface XmlAttribute {
+    namespaceUri: string;
+    name: string;
+    value: string;
+    source: SourcePosition | null;
+    resourceId: number;
+    compiledItem: Item | null;
+}
+export interface Item {
+    ref?: unknown;
+    str?: {
+        value: string;
+    };
+    rawStr?: {
+        value: string;
+    };
+    styledStr?: unknown;
+    file?: unknown;
+    id?: unknown;
+    prim?: {
+        booleanValue?: boolean;
+        intDecimalValue?: number;
+        floatValue?: number;
+    };
+}
+export interface Source {
+    pathIdx: number;
+    position: SourcePosition;
+}
+export interface SourcePosition {
+    lineNumber: number;
+    columnNumber: number;
+}
+export interface ResourceTable {
+    stringPool: StringPool;
+    package: Package[];
+    overlayable: unknown[];
+    toolFingerprint: unknown[];
+    dynamicRefTable: unknown;
+}
+export interface StringPool {
+    data: unknown;
+}
+export interface Package {
+    packageId: number;
+    packageName: string;
+    type: Type[];
+}
+export interface Type {
+    typeId: number;
+    name: string;
+    entry: Entry[];
+}
+export interface Entry {
+    entryId: number;
+    name: string;
+    visibility: unknown;
+    allowNew: unknown;
+    overlayableItem: unknown;
+    configValue: ConfigValue[];
+    stagedId: unknown;
+}
+export interface ConfigValue {
+    config: unknown;
+    value: Value;
+}
+export interface Value {
+    source: Source;
+    comment: string;
+    weak: boolean;
+    item?: Item;
+    compoundValue?: unknown;
+}

package/build/android/Resources.types.js

@@ -0,0 +1,4 @@
+/**
+ * Types mapped from the Resoruces.proto file.
+ */
+export {};

package/build/android/build-tools.d.ts

@@ -0,0 +1,32 @@
+import type { AndroidSigningOptions, NormalizedOptions } from '../types.js';
+export interface AndroidTools {
+    aapt2Path: string;
+    apksignerPath: string;
+    zipalignPath: string;
+}
+/**
+ * Get the paths to the Android build-tools.
+ */
+export declare function getAndroidBuildToolsAsync(options?: NormalizedOptions): Promise<AndroidTools>;
+/**
+ * Create an APK with proto-based resources.
+ */
+export declare function createProtoBasedResourcesAsync(options: NormalizedOptions): Promise<{
+    androidManiestFilePath: string;
+    resourcesPbFilePath: string;
+}>;
+/**
+ * Create an APK with binary-based resources.
+ */
+export declare function createBinaryBasedResourcesAsync(options: NormalizedOptions): Promise<string>;
+/**
+ * Create a resigned & updated APK.
+ * @param binaryApkPath The path to the binary-based resources APK returned from `createBinaryBasedResourcesAsync()`.
+ * @param appConfigPath The path to the app.config file returned from `generateAppConfigAsync()`.
+ * @returns
+ */
+export declare function createResignedApkAsync(binaryApkPath: string, appConfigPath: string, options: NormalizedOptions, signingOptions: AndroidSigningOptions): Promise<string>;
+/**
+ * Find the latest build-tools directory in the `ANDROID_SDK_ROOT` directory.
+ */
+export declare function findLatestBuildToolsDirAsync(): Promise<string | null>;

package/build/android/build-tools.js

@@ -0,0 +1,157 @@
+import spawnAsync from '@expo/turtle-spawn';
+import { glob } from 'glob';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+let cachedAndroidTools = null;
+/**
+ * Get the paths to the Android build-tools.
+ */
+export async function getAndroidBuildToolsAsync(options) {
+    if (cachedAndroidTools == null) {
+        const androidBuildToolsDir = options?.androidBuildToolsDir ?? (await findLatestBuildToolsDirAsync());
+        assert(androidBuildToolsDir != null, 'Unable to find the Android build-tools directory.');
+        cachedAndroidTools = {
+            aapt2Path: path.join(androidBuildToolsDir, 'aapt2'),
+            apksignerPath: path.join(androidBuildToolsDir, 'apksigner'),
+            zipalignPath: path.join(androidBuildToolsDir, 'zipalign'),
+        };
+    }
+    return cachedAndroidTools;
+}
+/**
+ * Create an APK with proto-based resources.
+ */
+export async function createProtoBasedResourcesAsync(options) {
+    const { sourceAppPath, workingDirectory } = options;
+    const { aapt2Path } = await getAndroidBuildToolsAsync(options);
+    const protoApkPath = path.join(workingDirectory, 'proto.apk');
+    await spawnAsync(aapt2Path, ['convert', '-o', protoApkPath, '--output-format', 'proto', '--keep-raw-values', sourceAppPath], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await spawnAsync('unzip', [protoApkPath, '-d', workingDirectory], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    const removeFiles = await glob('**/*', {
+        cwd: workingDirectory,
+        maxDepth: 1,
+        ignore: ['resources.pb', 'AndroidManifest.xml', 'res/**'],
+        absolute: true,
+    });
+    await Promise.all(removeFiles.map((file) => fs.rm(file, { recursive: true })));
+    return {
+        androidManiestFilePath: path.join(workingDirectory, 'AndroidManifest.xml'),
+        resourcesPbFilePath: path.join(workingDirectory, 'resources.pb'),
+    };
+}
+/**
+ * Create an APK with binary-based resources.
+ */
+export async function createBinaryBasedResourcesAsync(options) {
+    const { workingDirectory } = options;
+    const { aapt2Path } = await getAndroidBuildToolsAsync(options);
+    const protoUpdatedApkPath = path.join(workingDirectory, 'proto-updated.apk');
+    const binaryApkPath = path.join(workingDirectory, 'binary.apk');
+    await spawnAsync('zip', ['-r', '-0', protoUpdatedApkPath, 'resources.pb', 'AndroidManifest.xml', 'res'], {
+        cwd: workingDirectory,
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await spawnAsync(aapt2Path, [
+        'convert',
+        '-o',
+        binaryApkPath,
+        '--output-format',
+        'binary',
+        '--keep-raw-values',
+        protoUpdatedApkPath,
+    ], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    return binaryApkPath;
+}
+/**
+ * Create a resigned & updated APK.
+ * @param binaryApkPath The path to the binary-based resources APK returned from `createBinaryBasedResourcesAsync()`.
+ * @param appConfigPath The path to the app.config file returned from `generateAppConfigAsync()`.
+ * @returns
+ */
+export async function createResignedApkAsync(binaryApkPath, appConfigPath, options, signingOptions) {
+    const { workingDirectory } = options;
+    const { apksignerPath, zipalignPath } = await getAndroidBuildToolsAsync(options);
+    const unzipWorkingDirectory = path.join(workingDirectory, 'unzip');
+    const resignedApkPath = path.join(workingDirectory, 'resigned.apk');
+    const resignedApkUnalignedPath = path.join(workingDirectory, 'resigned-unaligned.apk');
+    await fs.mkdir(unzipWorkingDirectory, { recursive: true });
+    await spawnAsync('unzip', [options.sourceAppPath, '-d', unzipWorkingDirectory], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await spawnAsync('unzip', ['-o', binaryApkPath, '-d', unzipWorkingDirectory], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await fs.copyFile(appConfigPath, path.join(unzipWorkingDirectory, 'assets', 'app.config'));
+    await spawnAsync('zip', ['-r', '-0', resignedApkUnalignedPath, 'lib', 'resources.arsc'], {
+        cwd: unzipWorkingDirectory,
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await spawnAsync('zip', ['-r', resignedApkUnalignedPath, '.', '-x', 'lib/*', '-x', 'resources.arsc'], {
+        cwd: unzipWorkingDirectory,
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    await spawnAsync(zipalignPath, ['-v', '-p', '4', resignedApkUnalignedPath, resignedApkPath], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    const signerArgs = [
+        'sign',
+        '--ks',
+        signingOptions.keyStorePath,
+        '--ks-pass',
+        signingOptions.keyStorePassword,
+    ];
+    if (signingOptions.keyAlias) {
+        signerArgs.push('--ks-key-alias', signingOptions.keyAlias);
+    }
+    if (signingOptions.keyPassword) {
+        signerArgs.push('--key-pass', signingOptions.keyPassword);
+    }
+    signerArgs.push(resignedApkPath);
+    await spawnAsync(apksignerPath, signerArgs, {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    return resignedApkPath;
+}
+/**
+ * Find the latest build-tools directory in the `ANDROID_SDK_ROOT` directory.
+ */
+export async function findLatestBuildToolsDirAsync() {
+    const androidSdkRoot = process.env['ANDROID_SDK_ROOT'];
+    assert(androidSdkRoot != null, 'ANDROID_SDK_ROOT environment variable is not set');
+    const buildToolsDir = path.join(androidSdkRoot, 'build-tools');
+    try {
+        const entries = await fs.readdir(buildToolsDir, { withFileTypes: true });
+        const dirs = entries
+            .filter((entry) => entry.isDirectory())
+            .map((dir) => dir.name)
+            .sort((a, b) => {
+            // Convert version strings to numbers and compare
+            const versionA = a.split('.').map(Number);
+            const versionB = b.split('.').map(Number);
+            for (let i = 0; i < Math.min(versionA.length, versionB.length); i++) {
+                if (versionA[i] !== versionB[i]) {
+                    return versionB[i] - versionA[i];
+                }
+            }
+            return versionB.length - versionA.length;
+        });
+        if (dirs.length > 0) {
+            return path.join(buildToolsDir, dirs[0]);
+        }
+        else {
+            console.error('No build-tools directories found.');
+            return null;
+        }
+    }
+    catch (error) {
+        console.error(`Failed to read the build-tools directory: ${error}`);
+        return null;
+    }
+}

package/build/android/index.d.ts

@@ -0,0 +1,5 @@
+import type { Options } from '../types.js';
+/**
+ * Repack an Android app.
+ */
+export declare function repackAppAndroidAsync(_options: Options): Promise<string>;

package/build/android/index.js

@@ -0,0 +1,53 @@
+import { getConfig } from '@expo/config';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import pico from 'picocolors';
+import { createBinaryBasedResourcesAsync, createProtoBasedResourcesAsync, createResignedApkAsync, } from './build-tools.js';
+import { updateAndroidManifestAsync, updateResourcesAsync } from './resources.js';
+import { generateAppConfigAsync, resolveRuntimeVersionAsync } from '../expo.js';
+import logger from '../log.js';
+import { normalizeOptionAsync } from '../utils.js';
+/**
+ * Repack an Android app.
+ */
+export async function repackAppAndroidAsync(_options) {
+    const options = await normalizeOptionAsync(_options);
+    const { workingDirectory } = options;
+    await fs.mkdir(workingDirectory, { recursive: true });
+    const { exp } = getConfig(options.projectRoot, {
+        isPublicConfig: true,
+        skipSDKVersionRequirement: true,
+    });
+    const updatesRuntimeVersion = await resolveRuntimeVersionAsync(options, exp);
+    logger.log(pico.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
+    logger.time(`Unzipping APK and creating proto based resources`);
+    const { androidManiestFilePath, resourcesPbFilePath } = await createProtoBasedResourcesAsync(options);
+    logger.timeEnd(`Unzipping APK and creating proto based resources`);
+    logger.time(`Updating Androidmanifest.xml`);
+    await updateAndroidManifestAsync(exp, androidManiestFilePath, options, updatesRuntimeVersion);
+    logger.timeEnd(`Updating Androidmanifest.xml`);
+    logger.time(`Updating resources.pb`);
+    await updateResourcesAsync(exp, resourcesPbFilePath);
+    logger.timeEnd(`Updating resources.pb`);
+    logger.time(`Creating binary based resources`);
+    const binaryApkPath = await createBinaryBasedResourcesAsync(options);
+    logger.timeEnd(`Creating binary based resources`);
+    logger.time(`Generating app.config`);
+    const appConfigPath = await generateAppConfigAsync(options, exp);
+    logger.timeEnd(`Generating app.config`);
+    logger.time(`Creating updated apk`);
+    const outputApk = await createResignedApkAsync(binaryApkPath, appConfigPath, options, {
+        keyStorePath: options.androidSigningOptions?.keyStorePath ??
+            path.resolve(__dirname, '../assets/debug.keystore'),
+        keyStorePassword: options.androidSigningOptions?.keyStorePassword ?? 'android',
+        keyAlias: options.androidSigningOptions?.keyAlias,
+        keyPassword: options.androidSigningOptions?.keyPassword,
+    });
+    logger.timeEnd(`Creating updated apk`);
+    await fs.rename(outputApk, options.outputPath);
+    try {
+        await fs.rmdir(workingDirectory, { recursive: true });
+    }
+    catch { }
+    return options.outputPath;
+}

package/build/android/resources.d.ts

@@ -0,0 +1,10 @@
+import { type ExpoConfig } from '@expo/config';
+import type { NormalizedOptions } from '../types.js';
+/**
+ * Update resources inside the **resources.pb** file.
+ */
+export declare function updateResourcesAsync(config: ExpoConfig, resourcesPbFilePath: string): Promise<void>;
+/**
+ * Update the proto-based AndroidManiest.xml.
+ */
+export declare function updateAndroidManifestAsync(config: ExpoConfig, androidManiestFilePath: string, options: NormalizedOptions, updatesRuntimeVersion: string): Promise<void>;

package/build/android/resources.js

@@ -0,0 +1,170 @@
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import protobuf from 'protobufjs';
+import { requireNotNull } from '../utils.js';
+/**
+ * Update resources inside the **resources.pb** file.
+ */
+export async function updateResourcesAsync(config, resourcesPbFilePath) {
+    const root = await protobuf.load(path.join(__dirname, '../../assets', 'Resources.proto'));
+    const resourceTableType = root.lookupType('aapt.pb.ResourceTable');
+    const resourceTable = await decodeProtoFile(resourceTableType, resourcesPbFilePath);
+    // [0] Update the package name
+    assert(resourceTable.package.length === 1, 'Expected only one package');
+    assert(config.android?.package, 'Expected android.package to be defined');
+    resourceTable.package[0].packageName = config.android.package;
+    const stringType = resourceTable.package[0].type.find((type) => type.name === 'string');
+    const stringEntries = stringType?.entry;
+    // [1] Update the `app_name` in **res/values/strings.xml**.
+    const appNameEntry = stringEntries?.find((entry) => entry.name === 'app_name');
+    assert(appNameEntry?.configValue?.[0].value?.item?.str?.value === 'HelloWorld', 'Expected app_name to be predefined "HelloWorld"');
+    appNameEntry.configValue[0].value.item.str.value = config.name;
+    await encodeProtoFile(resourceTableType, resourcesPbFilePath, resourceTable);
+}
+/**
+ * Update the proto-based AndroidManiest.xml.
+ */
+export async function updateAndroidManifestAsync(config, androidManiestFilePath, options, updatesRuntimeVersion) {
+    const root = await protobuf.load(path.join(__dirname, '../../assets', 'Resources.proto'));
+    const xmlNodeType = root.lookupType('aapt.pb.XmlNode');
+    const rootNode = await decodeProtoFile(xmlNodeType, androidManiestFilePath);
+    // [0] Update the package name
+    replaceXmlAttributeValue(rootNode, (value) => value.replace(/dev\.expo\.templatedefault\.appid/g, requireNotNull(config.android?.package)));
+    // [1] Update the scheme in the intent-filters
+    const intentFilterViewActionNodes = findXmlNodes(rootNode, (node) => node.element?.name === 'intent-filter' &&
+        findXmlNodes(node, (node) => node.element?.name === 'action' &&
+            node.element?.attribute[0]?.value === 'android.intent.action.VIEW').length > 0);
+    const firstScheme = Array.isArray(config.scheme) ? config.scheme[0] : config.scheme;
+    for (const node of intentFilterViewActionNodes) {
+        replaceXmlAttributeValue(node, (value) => value
+            // scheme in app.json
+            .replace(/^myapp$/g, requireNotNull(firstScheme))
+            // android.package in app.json
+            .replace(/^dev\.expo\.templatedefault$/g, requireNotNull(config.android?.package))
+            // default scheme generated from slug in app.json
+            .replace(/^exp\+expo-template-default$/g, `exp+${requireNotNull(config.slug)}`));
+    }
+    // [2] expo-updates configuration
+    const mainApplicationNode = findXmlNodes(rootNode, (node) => node.element?.name === 'application' &&
+        node.element?.attribute.find((attr) => attr.name === 'name' && attr.value.endsWith('.MainApplication')) != null)[0];
+    assert(mainApplicationNode != null, 'Expected application node to be present');
+    mutateExpoUpdatesConfigAsync(mainApplicationNode, config, updatesRuntimeVersion);
+    await encodeProtoFile(xmlNodeType, androidManiestFilePath, rootNode);
+}
+//#region Internals
+/**
+ * Update the `expo-updates` configuration in the Android project.
+ */
+function mutateExpoUpdatesConfigAsync(mainApplicationNode, config, runtimeVersion) {
+    const updateEnabledNodeIndex = mainApplicationNode.element?.child.findIndex((child) => child.element?.name === 'meta-data' &&
+        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.ENABLED'));
+    assert(updateEnabledNodeIndex != null && updateEnabledNodeIndex >= 0, `Expected 'expo.modules.updates.ENABLED' node to be present`);
+    const updateEnabledNode = requireNotNull(mainApplicationNode.element?.child[updateEnabledNodeIndex]);
+    // [0] expo.modules.updates.ENABLED
+    const updateEnabledPrimValue = updateEnabledNode.element?.attribute?.[1]?.compiledItem?.prim;
+    assert(updateEnabledPrimValue != null, 'Expected updateEnabledPrimValue to be present');
+    updateEnabledPrimValue.booleanValue = true;
+    // [1] expo.modules.updates.EXPO_RUNTIME_VERSION
+    const updateRuntimeVersionNode = mainApplicationNode.element?.child.find((child) => child.element?.name === 'meta-data' &&
+        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.EXPO_RUNTIME_VERSION'));
+    if (updateRuntimeVersionNode == null) {
+        mainApplicationNode.element?.child.splice(updateEnabledNodeIndex + 1, 0, createUpdateStringNode(updateEnabledNode, 'expo.modules.updates.EXPO_RUNTIME_VERSION', runtimeVersion));
+    }
+    else {
+        assert(updateRuntimeVersionNode.element != null);
+        updateRuntimeVersionNode.element.attribute[1].value = runtimeVersion;
+    }
+    // [2] expo.modules.updates.EXPO_UPDATE_URL
+    const updateUrlNode = mainApplicationNode.element?.child.find((child) => child.element?.name === 'meta-data' &&
+        child.element?.attribute.find((attr) => attr.name === 'name' && attr.value === 'expo.modules.updates.EXPO_UPDATE_URL'));
+    const updateUrl = config.updates?.url;
+    assert(updateUrl);
+    if (updateUrlNode == null) {
+        mainApplicationNode.element?.child.splice(updateEnabledNodeIndex + 1, 0, createUpdateStringNode(updateEnabledNode, 'expo.modules.updates.EXPO_UPDATE_URL', updateUrl));
+    }
+    else {
+        assert(updateUrlNode.element != null);
+        updateUrlNode.element.attribute[1].value = updateUrl;
+    }
+}
+/**
+ * Decode the proto-encoded file from `filePath` with the given `protoTypeString` and return as JSON object.
+ */
+async function decodeProtoFile(protoType, filePath) {
+    const buffer = await fs.readFile(filePath);
+    const message = await protoType.decode(buffer);
+    const json = protoType.toObject(message, {
+        longs: String,
+        enums: String,
+        bytes: String,
+        defaults: true,
+        arrays: true,
+        objects: true,
+        oneofs: true,
+    });
+    return json;
+}
+async function encodeProtoFile(protoType, filePath, json) {
+    const updatedMessage = protoType.fromObject(json);
+    const updatedBuffer = protoType.encode(updatedMessage).finish();
+    await fs.writeFile(filePath, updatedBuffer);
+}
+/**
+ * Recursively find XML nodes that satisfy the given `predicate`.
+ */
+function findXmlNodes(rootNode, predicate) {
+    if (rootNode.element == null) {
+        return [];
+    }
+    if (predicate(rootNode)) {
+        return [rootNode];
+    }
+    return rootNode.element.child.flatMap((child) => findXmlNodes(child, predicate));
+}
+/**
+ * Recursively replace the attribute values in the XML nodes's attributes.
+ */
+function replaceXmlAttributeValue(node, replacer) {
+    if (node.element == null) {
+        return;
+    }
+    const attrs = node.element.attribute;
+    for (const attr of attrs) {
+        attr.value = replacer(attr.value);
+    }
+    for (const child of node.element.child) {
+        replaceXmlAttributeValue(child, replacer);
+    }
+}
+/**
+ * Create a new `meta-data` node with the given `name` and `value`.
+ * We use the `updateEnabledNode` as the source to clone most of the properties.
+ */
+function createUpdateStringNode(updateEnabledNode, name, value) {
+    return {
+        ...updateEnabledNode,
+        element: {
+            ...requireNotNull(updateEnabledNode.element),
+            attribute: [
+                {
+                    namespaceUri: 'http://schemas.android.com/apk/res/android',
+                    name: 'name',
+                    value: name,
+                    source: null,
+                    resourceId: 16842755,
+                    compiledItem: null,
+                },
+                {
+                    namespaceUri: 'http://schemas.android.com/apk/res/android',
+                    name: 'value',
+                    value,
+                    source: null,
+                    resourceId: 16842788,
+                    compiledItem: null,
+                },
+            ],
+        },
+    };
+}
+//#endregion

package/build/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/build/cli.js

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { repackAppAndroidAsync, repackAppIosAsync } from './index.js';
+import { resignIpaAsync } from './ios/index.js';
+import logger from './log.js';
+const program = new Command('repack-app')
+    .requiredOption('-p, --platform <platform>', 'Platform to repack the app for')
+    .requiredOption('--source-app <path>', 'Path to the source app file')
+    .option('--android-build-tools-dir <path>', 'Path to the Android build tools directory')
+    .option('-w, --working-directory <path>', 'Path to the working directory')
+    .option('-o, --output <path>', 'Path to the output APK file')
+    // Android signing options
+    .option('--ks <path>', 'Path to the keystore file')
+    .option('--ks-pass <password>', 'Keystore password', 'pass:android')
+    .option('--ks-key-alias <alias>', 'Keystore key alias')
+    .option('--ks-key-pass <password>', 'Keystore key password')
+    .option('-v, --verbose', 'Enable verbose logging')
+    // iOS signing options
+    .option('--signing-identity <identity>', 'Signing identity')
+    .option('--provisioning-profile <path>', 'Path to the provisioning profile')
+    // arguments
+    .argument('<project-root>', 'Path to the project root')
+    .parse(process.argv);
+async function runAsync() {
+    const platform = program.opts().platform;
+    const projectRoot = program.args[0];
+    if (platform === 'android') {
+        const outputPath = await repackAppAndroidAsync({
+            platform: program.opts().platform,
+            projectRoot,
+            verbose: !!program.opts().verbose,
+            sourceAppPath: program.opts().sourceApp,
+            workingDirectory: program.opts().workingDirectory,
+            outputPath: program.opts().output,
+            androidSigningOptions: {
+                keyStorePath: program.opts().ks,
+                keyStorePassword: program.opts().ksPass,
+                keyAlias: program.opts().ksKeyAlias,
+                keyPassword: program.opts().ksKeyPass,
+            },
+            androidBuildToolsDir: program.opts().androidBuildToolsDir,
+        });
+        logger.log(pico.green(`Updated APK created at ${outputPath}`));
+    }
+    else if (platform === 'ios') {
+        const options = {
+            platform: program.opts().platform,
+            projectRoot,
+            verbose: !!program.opts().verbose,
+            sourceAppPath: program.opts().sourceApp,
+            workingDirectory: program.opts().workingDirectory,
+            outputPath: program.opts().output,
+            iosSigningOptions: {
+                signingIdentity: program.opts().signingIdentity,
+                provisioningProfile: program.opts().provisioningProfile,
+            },
+        };
+        const outputPath = await repackAppIosAsync(options);
+        logger.log(pico.green(`Updated IPA created at ${outputPath}`));
+        if (options.iosSigningOptions?.signingIdentity &&
+            options.iosSigningOptions?.provisioningProfile) {
+            logger.log(pico.green(`Resigning the IPA at ${outputPath}`));
+            await resignIpaAsync(outputPath, options.iosSigningOptions, options);
+        }
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+(async () => {
+    try {
+        await runAsync();
+    }
+    catch (e) {
+        console.error('Uncaught Error', e);
+        process.exit(1);
+    }
+})();

package/build/expo.d.ts

@@ -0,0 +1,10 @@
+import { type ExpoConfig } from '@expo/config';
+import type { NormalizedOptions } from './types.js';
+/**
+ * Generate the app.config file for the Android app.
+ */
+export declare function generateAppConfigAsync(options: NormalizedOptions, config: ExpoConfig): Promise<string>;
+/**
+ * Resolve the `runtimeVersion` for expo-updates.
+ */
+export declare function resolveRuntimeVersionAsync(options: NormalizedOptions, config: ExpoConfig): Promise<string>;

package/build/expo.js

@@ -0,0 +1,26 @@
+import spawnAsync from '@expo/turtle-spawn';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import resolveFrom from 'resolve-from';
+/**
+ * Generate the app.config file for the Android app.
+ */
+export async function generateAppConfigAsync(options, config) {
+    const { workingDirectory } = options;
+    const appConfigPath = path.join(workingDirectory, 'app.config');
+    await fs.writeFile(appConfigPath, JSON.stringify(config));
+    return appConfigPath;
+}
+/**
+ * Resolve the `runtimeVersion` for expo-updates.
+ */
+export async function resolveRuntimeVersionAsync(options, config) {
+    const { projectRoot } = options;
+    const cli = resolveFrom.silent(projectRoot, 'expo-updates/bin/cli') ??
+        resolveFrom(projectRoot, 'expo-updates/bin/cli.js');
+    const proc = await spawnAsync(cli, ['runtimeversion:resolve', '--platform', 'android', '--workflow', 'managed'], {
+        cwd: projectRoot,
+    });
+    const runtimeVersion = JSON.parse(proc.stdout).runtimeVersion;
+    return runtimeVersion ?? config.version ?? '1.0.0';
+}

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { repackAppAndroidAsync } from './android/index.js';
+export { repackAppIosAsync } from './ios/index.js';

package/build/index.js

@@ -0,0 +1,2 @@
+export { repackAppAndroidAsync } from './android/index.js';
+export { repackAppIosAsync } from './ios/index.js';

package/build/ios/build-tools.d.ts

@@ -0,0 +1,14 @@
+import { type ExpoConfig } from '@expo/config';
+import type { NormalizedOptions } from '../types';
+/**
+ * Unzip the IPA file.
+ */
+export declare function unzipIpaAsync(options: NormalizedOptions): Promise<string>;
+/**
+ * Update some binary files.
+ */
+export declare function updateFilesAsync(config: ExpoConfig, appWorkingDirectory: string): Promise<string>;
+/**
+ * From the given working .app directory, create a new .ipa file.
+ */
+export declare function createIpaAsync(options: NormalizedOptions, appWorkingDirectory: string): Promise<string>;