@expo/repack-app 0.0.1

package/build/ios/build-tools.js

@@ -0,0 +1,43 @@
+import spawnAsync from '@expo/turtle-spawn';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { directoryExistsAsync } from '../utils';
+/**
+ * Unzip the IPA file.
+ */
+export async function unzipIpaAsync(options) {
+    const unzipWorkingDirectory = path.join(options.workingDirectory, 'unzip');
+    await spawnAsync('unzip', [options.sourceAppPath, '-d', unzipWorkingDirectory], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    const appWorkingDirectory = path.join(unzipWorkingDirectory, 'Payload', 'HelloWorld.app');
+    assert(await directoryExistsAsync(appWorkingDirectory));
+    return appWorkingDirectory;
+}
+/**
+ * Update some binary files.
+ */
+export async function updateFilesAsync(config, appWorkingDirectory) {
+    const parentDir = path.dirname(appWorkingDirectory);
+    const newAppWorkingDirectory = path.join(parentDir, `${config.name}.app`);
+    // [0] Update the .app directory
+    await fs.rename(path.join(parentDir, 'HelloWorld.app'), newAppWorkingDirectory);
+    // [1] Rename the executable
+    await fs.rename(path.join(newAppWorkingDirectory, 'HelloWorld'), path.join(newAppWorkingDirectory, config.name));
+    return newAppWorkingDirectory;
+}
+/**
+ * From the given working .app directory, create a new .ipa file.
+ */
+export async function createIpaAsync(options, appWorkingDirectory) {
+    const { workingDirectory } = options;
+    await fs.mkdir(path.join(workingDirectory, 'Payload'), { recursive: true });
+    await fs.rename(appWorkingDirectory, path.join(workingDirectory, 'Payload', path.basename(appWorkingDirectory)));
+    const outputIpaPath = path.join(workingDirectory, 'repacked.ipa');
+    await spawnAsync('zip', ['-r', outputIpaPath, 'Payload'], {
+        cwd: workingDirectory,
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    return outputIpaPath;
+}

package/build/ios/index.d.ts

@@ -0,0 +1,9 @@
+import type { IosSigningOptions, Options } from '../types.js';
+/**
+ * Repack an iOS app.
+ */
+export declare function repackAppIosAsync(_options: Options): Promise<string>;
+/**
+ * Resign an IPA by fastlane.
+ */
+export declare function resignIpaAsync(ipaPath: string, signingOptions: IosSigningOptions, options: Options): Promise<void>;

package/build/ios/index.js

@@ -0,0 +1,65 @@
+import { getConfig } from '@expo/config';
+import spawnAsync from '@expo/turtle-spawn';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import pico from 'picocolors';
+import { createIpaAsync, unzipIpaAsync, updateFilesAsync } from './build-tools.js';
+import { updateExpoPlistAsync, updateInfoPlistAsync } from './resources.js';
+import { generateAppConfigAsync, resolveRuntimeVersionAsync } from '../expo.js';
+import logger from '../log.js';
+import { normalizeOptionAsync } from '../utils.js';
+/**
+ * Repack an iOS app.
+ */
+export async function repackAppIosAsync(_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 IPA`);
+    let appWorkingDirectory = await unzipIpaAsync(options);
+    appWorkingDirectory = await updateFilesAsync(exp, appWorkingDirectory);
+    logger.timeEnd(`Unzipping IPA`);
+    logger.time(`Updating Info.plist`);
+    await updateInfoPlistAsync(exp, path.join(appWorkingDirectory, 'Info.plist'), options);
+    logger.timeEnd(`Updating Info.plist`);
+    logger.time(`Updating Expo.plist`);
+    await updateExpoPlistAsync(exp, path.join(appWorkingDirectory, 'Expo.plist'), updatesRuntimeVersion, options);
+    logger.timeEnd(`Updating Expo.plist`);
+    logger.time(`Generating app.config`);
+    const appConfigPath = await generateAppConfigAsync(options, exp);
+    await fs.copyFile(appConfigPath, path.join(appWorkingDirectory, 'EXConstants.bundle', 'app.config'));
+    logger.timeEnd(`Generating app.config`);
+    logger.time(`Creating updated ipa`);
+    const outputIpa = await createIpaAsync(options, appWorkingDirectory);
+    logger.timeEnd(`Creating updated ipa`);
+    await fs.rename(outputIpa, options.outputPath);
+    try {
+        await fs.rmdir(workingDirectory, { recursive: true });
+    }
+    catch { }
+    return options.outputPath;
+}
+/**
+ * Resign an IPA by fastlane.
+ */
+export async function resignIpaAsync(ipaPath, signingOptions, options) {
+    const args = [
+        'run',
+        'resign',
+        `ipa:${ipaPath}`,
+        `signing_identity:${signingOptions.signingIdentity}`,
+        `provisioning_profile:${signingOptions.provisioningProfile}`,
+    ];
+    if (signingOptions.keychainPath) {
+        args.push(`keychain_path:${signingOptions.keychainPath}`);
+    }
+    await spawnAsync('fastlane', args, {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+}

package/build/ios/resources.d.ts

@@ -0,0 +1,10 @@
+import { type ExpoConfig } from '@expo/config';
+import type { NormalizedOptions } from '../types';
+/**
+ * Update the Info.plist file.
+ */
+export declare function updateInfoPlistAsync(config: ExpoConfig, infoPlistPath: string, options: NormalizedOptions): Promise<void>;
+/**
+ * Update the Expo.plist file.
+ */
+export declare function updateExpoPlistAsync(config: ExpoConfig, expoPlistPath: string, runtimeVersion: string, options: NormalizedOptions): Promise<void>;

package/build/ios/resources.js

@@ -0,0 +1,69 @@
+import plist from '@expo/plist';
+import spawnAsync from '@expo/turtle-spawn';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import { requireNotNull } from '../utils';
+/**
+ * Update the Info.plist file.
+ */
+export async function updateInfoPlistAsync(config, infoPlistPath, options) {
+    const bundleIdentifier = config.ios?.bundleIdentifier;
+    assert(bundleIdentifier, 'The `bundleIdentifier` must be specified in the `ios` config.');
+    const firstScheme = Array.isArray(config.scheme) ? config.scheme[0] : config.scheme;
+    await updateBinaryPlistAsync(infoPlistPath, options, (data) => {
+        const urlTypes = data.CFBundleURLTypes.slice();
+        for (const urlType of urlTypes) {
+            if (Array.isArray(urlType.CFBundleURLSchemes)) {
+                const schemes = urlType.CFBundleURLSchemes.map((scheme) => {
+                    return (scheme
+                        // scheme in app.json
+                        .replace(/^myapp$/g, requireNotNull(firstScheme))
+                        // ios.bundleIdentifier in app.json
+                        .replace(/^dev.expo.templatedefault$/g, requireNotNull(bundleIdentifier))
+                        // default scheme generated from slug in app.json
+                        .replace(/^exp\+expo-template-default$/g, `exp+${requireNotNull(config.slug)}`));
+                });
+                urlType.CFBundleURLSchemes = schemes;
+            }
+        }
+        const userActivityTypes = data.NSUserActivityTypes.map((activityType) => activityType.replace(/^dev.expo.templatedefault/g, bundleIdentifier));
+        return {
+            ...data,
+            CFBundleDisplayName: config.name,
+            CFBundleName: config.name,
+            CFBundleExecutable: config.name,
+            CFBundleIdentifier: bundleIdentifier,
+            NSUserActivityTypes: userActivityTypes,
+        };
+    });
+}
+/**
+ * Update the Expo.plist file.
+ */
+export async function updateExpoPlistAsync(config, expoPlistPath, runtimeVersion, options) {
+    await updateBinaryPlistAsync(expoPlistPath, options, (data) => {
+        const updateUrl = config.updates?.url;
+        assert(updateUrl);
+        return {
+            ...data,
+            EXUpdatesEnabled: true,
+            EXUpdatesRuntimeVersion: runtimeVersion,
+            EXUpdatesURL: updateUrl,
+        };
+    });
+}
+//#region Internals
+async function updateBinaryPlistAsync(plistPath, options, updater) {
+    await spawnAsync('plutil', ['-convert', 'xml1', plistPath], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+    const contents = await fs.readFile(plistPath, 'utf8');
+    const data = await plist.parse(contents);
+    const updatedData = updater(data);
+    const updatedContents = plist.build(updatedData);
+    await fs.writeFile(plistPath, updatedContents);
+    await spawnAsync('plutil', ['-convert', 'binary1', plistPath], {
+        stdio: options.verbose ? 'inherit' : 'ignore',
+    });
+}
+//#endregion

package/build/log.d.ts

@@ -0,0 +1,13 @@
+export declare function log(...message: string[]): void;
+export declare function warn(...message: string[]): void;
+export declare function error(...message: string[]): void;
+export declare function time(label?: string): void;
+export declare function timeEnd(label?: string): void;
+declare const _default: {
+    log: typeof log;
+    warn: typeof warn;
+    error: typeof error;
+    time: typeof time;
+    timeEnd: typeof timeEnd;
+};
+export default _default;

package/build/log.js

@@ -0,0 +1,23 @@
+import pico from 'picocolors';
+export function log(...message) {
+    console.log(...message);
+}
+export function warn(...message) {
+    console.warn(...message.map((value) => pico.yellow(value)));
+}
+export function error(...message) {
+    console.error(...message);
+}
+export function time(label) {
+    console.time(label);
+}
+export function timeEnd(label) {
+    console.timeEnd(label);
+}
+export default {
+    log,
+    warn,
+    error,
+    time,
+    timeEnd,
+};

package/build/types.d.ts

@@ -0,0 +1,85 @@
+export interface Options {
+    /**
+     * The platform to repack the app for.
+     */
+    platform: 'android' | 'ios';
+    /**
+     * The path to the project root directory.
+     */
+    projectRoot: string;
+    /**
+     * The prebuilt app file path that acts as a source for repacking.
+     */
+    sourceAppPath: string;
+    /**
+     * Working directory.
+     */
+    workingDirectory?: string;
+    /**
+     * The path to the output app file.
+     * @default `projectRoot/repacked.apk` or `projectRoot/repacked.ipa`
+     */
+    outputPath?: string;
+    /**
+     * Enable verbose logging.
+     */
+    verbose?: boolean;
+    /**
+     * The options for signing the android app.
+     */
+    androidSigningOptions?: AndroidSigningOptions;
+    /**
+     * The path to the Android SDK build-tools directory.
+     * @default Try to find the latest build-tools directory in the `ANDROID_SDK_ROOT` directory.
+     */
+    androidBuildToolsDir?: string;
+    /**
+     * The options for signing the ios app.
+     */
+    iosSigningOptions?: IosSigningOptions;
+}
+export interface NormalizedOptions extends Options {
+    workingDirectory: NonNullable<Options['workingDirectory']>;
+    outputPath: NonNullable<Options['outputPath']>;
+}
+export interface AndroidSigningOptions {
+    /**
+     * Load private key and certificate chain from the Java
+     * KeyStore initialized from the specified file.
+     */
+    keyStorePath: string;
+    /**
+     * KeyStore password.
+     * The following formats are supported:
+     *   - pass:<password> password provided inline
+     *   - env:<name>      password provided in the named environment variable
+     *   - file:<file>     password provided in the named file, as a single line
+     */
+    keyStorePassword: string;
+    /**
+     * Alias under which the private key and certificate are stored in the KeyStore.
+     */
+    keyAlias?: string;
+    /**
+     * Password with which the private key is protected.
+     * The following formats are supported:
+     *   - pass:<password> password provided inline
+     *   - env:<name>      password provided in the named environment variable
+     *   - file:<file>     password provided in the named file, as a single line
+     */
+    keyPassword?: string;
+}
+export interface IosSigningOptions {
+    /**
+     * Code signing identity.
+     */
+    signingIdentity: string;
+    /**
+     * Path to your provisioning_profile.
+     */
+    provisioningProfile: string;
+    /**
+     * Provide a path to a keychain file that should be used by /usr/bin/codesign
+     */
+    keychainPath?: string;
+}

package/build/types.js

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

package/build/utils.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizedOptions, Options } from './types';
+/**
+ * Check if a directory exists.
+ */
+export declare function directoryExistsAsync(file: string): Promise<boolean>;
+/**
+ * Return the non-null value.
+ */
+export declare function requireNotNull<T>(value: T | null | undefined): T;
+/**
+ * Normalize the options.
+ */
+export declare function normalizeOptionAsync(options: Options): Promise<NormalizedOptions>;

package/build/utils.js

@@ -0,0 +1,27 @@
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Check if a directory exists.
+ */
+export async function directoryExistsAsync(file) {
+    return (await fs.stat(file).catch(() => null))?.isDirectory() ?? false;
+}
+/**
+ * Return the non-null value.
+ */
+export function requireNotNull(value) {
+    assert(value != null, 'Expected value to be non-null');
+    return value;
+}
+/**
+ * Normalize the options.
+ */
+export async function normalizeOptionAsync(options) {
+    const fileExt = options.platform === 'android' ? '.apk' : '.ipa';
+    return {
+        ...options,
+        workingDirectory: options.workingDirectory ?? (await fs.mkdtemp(path.join(require('temp-dir'), 'repack-app-'))),
+        outputPath: options.outputPath ?? path.join(options.projectRoot, `repacked${fileExt}`),
+    };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@expo/repack-app",
+  "version": "0.0.1",
+  "description": "Repacking tool for Expo apps",
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "prepare": "expo-module clean && tsc",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "test": "expo-module test",
+    "typecheck": "expo-module typecheck"
+  },
+  "bin": {
+    "repack-app": "bin/cli.js"
+  },
+  "files": [
+    "assets",
+    "bin",
+    "build"
+  ],
+  "author": "650 Industries, Inc.",
+  "license": "BUSL-1.1",
+  "dependencies": {
+    "@expo/config": "^8.5.6",
+    "@expo/turtle-spawn": "^1.0.57",
+    "commander": "^12.0.0",
+    "glob": "^10.3.12",
+    "picocolors": "^1.0.0",
+    "protobufjs": "^7.2.6",
+    "resolve-from": "^5.0.0",
+    "temp-dir": "^2.0.0"
+  },
+  "devDependencies": {
+    "@tsconfig/node20": "^20.1.4",
+    "eslint": "^8.57.0",
+    "expo-module-scripts": "^3.4.2",
+    "typescript": "^5.4.5"
+  }
+}