@expo/repack-app 0.1.3 → 0.1.5

package/build/android/apktool.js

@@ -7,7 +7,6 @@ exports.decodeApkAsync = decodeApkAsync;
 exports.rebuildApkAsync = rebuildApkAsync;
 exports.addBundleAssetsToDecodedApkAsync = addBundleAssetsToDecodedApkAsync;
 exports.addRenameManifestPackageAsync = addRenameManifestPackageAsync;
-const steps_1 = require("@expo/steps");
 const promises_1 = __importDefault(require("fs/promises"));
 const glob_1 = require("glob");
 const node_assert_1 = __importDefault(require("node:assert"));
@@ -18,23 +17,31 @@ let cachedApktoolPath = null;
  * Decode the APK file using APKTool.
  */
 async function decodeApkAsync(apkPath, options) {
-    const { workingDirectory } = options;
+    const { spawnAsync, workingDirectory } = options;
     const apktoolPath = await getApktoolPathAsync();
     const outputPath = 'decoded-apk';
-    await (0, steps_1.spawnAsync)('java', ['-jar', apktoolPath, 'decode', apkPath, '-s', '-o', outputPath], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
-        : { cwd: workingDirectory });
+    await spawnAsync('java', ['-jar', apktoolPath, 'decode', apkPath, '-s', '-o', outputPath], {
+        cwd: workingDirectory,
+    });
     return node_path_1.default.join(workingDirectory, outputPath);
 }
 /**
  * Rebuild the decoded APK file using APKTool.
  */
 async function rebuildApkAsync(decodedApkRoot, options) {
-    const { workingDirectory } = options;
+    const { spawnAsync, workingDirectory } = options;
     const apktoolPath = await getApktoolPathAsync();
     const apktoolPackedApkName = 'apktool-packed.apk';
     const apktoolPackedApkPath = node_path_1.default.resolve(workingDirectory, apktoolPackedApkName);
-    await (0, steps_1.spawnAsync)('java', ['-jar', apktoolPath, 'build', '-o', apktoolPackedApkPath, '--use-aapt2', decodedApkRoot], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await spawnAsync('java', [
+        '-jar',
+        apktoolPath,
+        'build',
+        '-o',
+        apktoolPackedApkPath,
+        '--use-aapt2',
+        decodedApkRoot,
+    ]);
     return apktoolPackedApkPath;
 }
 /**

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

@@ -22,4 +22,4 @@ export declare function findLatestBuildToolsDirAsync(): Promise<string | null>;
 /**
  * Search for classes in the APK with the given app ID pattern passing to grep.
  */
-export declare function searchDexClassesAsync(unzipApkRoot: string, grepAppIdPattern: string): Promise<Set<string>>;
+export declare function searchDexClassesAsync(unzipApkRoot: string, grepAppIdPattern: string, options: NormalizedOptions): Promise<Set<string>>;

package/build/android/build-tools.js

@@ -7,7 +7,6 @@ exports.getAndroidBuildToolsAsync = getAndroidBuildToolsAsync;
 exports.createResignedApkAsync = createResignedApkAsync;
 exports.findLatestBuildToolsDirAsync = findLatestBuildToolsDirAsync;
 exports.searchDexClassesAsync = searchDexClassesAsync;
-const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -34,17 +33,15 @@ async function getAndroidBuildToolsAsync(options) {
  * @returns
  */
 async function createResignedApkAsync(unzippedApkRoot, options, signingOptions) {
-    const { workingDirectory } = options;
+    const { spawnAsync, workingDirectory } = options;
     const { apksignerPath, zipalignPath } = await getAndroidBuildToolsAsync(options);
     const resignedApkPath = node_path_1.default.join(workingDirectory, 'resigned.apk');
     const resignedApkUnalignedPath = node_path_1.default.resolve(workingDirectory, 'resigned-unaligned.apk');
-    await (0, steps_1.spawnAsync)('zip', ['-r', '-0', resignedApkUnalignedPath, 'lib', 'resources.arsc'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: unzippedApkRoot }
-        : { cwd: unzippedApkRoot });
-    await (0, steps_1.spawnAsync)('zip', ['-r', resignedApkUnalignedPath, '.', '-x', 'lib/*', '-x', 'resources.arsc'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: unzippedApkRoot }
-        : { cwd: unzippedApkRoot });
-    await (0, steps_1.spawnAsync)(zipalignPath, ['-v', '-p', '4', resignedApkUnalignedPath, resignedApkPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await spawnAsync('zip', ['-r', '-0', resignedApkUnalignedPath, 'lib', 'resources.arsc'], {
+        cwd: unzippedApkRoot,
+    });
+    await spawnAsync('zip', ['-r', resignedApkUnalignedPath, '.', '-x', 'lib/*', '-x', 'resources.arsc'], { cwd: unzippedApkRoot });
+    await spawnAsync(zipalignPath, ['-v', '-p', '4', resignedApkUnalignedPath, resignedApkPath]);
     const signerArgs = [
         'sign',
         '--ks',
@@ -59,7 +56,7 @@ async function createResignedApkAsync(unzippedApkRoot, options, signingOptions)
         signerArgs.push('--key-pass', signingOptions.keyPassword);
     }
     signerArgs.push(resignedApkPath);
-    await (0, steps_1.spawnAsync)(apksignerPath, signerArgs, options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await spawnAsync(apksignerPath, signerArgs);
     return resignedApkPath;
 }
 /**
@@ -101,10 +98,11 @@ async function findLatestBuildToolsDirAsync() {
 /**
  * Search for classes in the APK with the given app ID pattern passing to grep.
  */
-async function searchDexClassesAsync(unzipApkRoot, grepAppIdPattern) {
+async function searchDexClassesAsync(unzipApkRoot, grepAppIdPattern, options) {
+    const { spawnAsync } = options;
     const { dexdumpPath } = await getAndroidBuildToolsAsync();
     const grepPattern = `"^  Class descriptor  : 'L${grepAppIdPattern.replace(/\./g, '/')}\\/"`;
-    const { stdout } = await (0, steps_1.spawnAsync)(dexdumpPath, ['classes*.dex', '|', 'grep', grepPattern], {
+    const { stdout } = await spawnAsync(dexdumpPath, ['classes*.dex', '|', 'grep', grepPattern], {
         cwd: unzipApkRoot,
         shell: true,
     });

package/build/android/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repackAppAndroidAsync = repackAppAndroidAsync;
-const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -19,7 +18,7 @@ const utils_1 = require("../utils");
  */
 async function repackAppAndroidAsync(_options) {
     const options = await (0, utils_1.normalizeOptionAsync)(_options);
-    const { workingDirectory, logger } = options;
+    const { logger, spawnAsync, workingDirectory } = options;
     await promises_1.default.mkdir(workingDirectory, { recursive: true });
     const { exp } = (0, expo_1.getExpoConfig)(options.projectRoot, {
         isPublicConfig: true,
@@ -32,22 +31,22 @@ async function repackAppAndroidAsync(_options) {
         : null;
     logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
     if (options.exportEmbedOptions != null) {
-        logger.info(`Generating bundle`);
+        logger.time(`Generating bundle`);
         const { assetRoot, bundleOutputPath } = await (0, expo_1.generateBundleAssetsAsync)(exp, options);
-        logger.info(`Finished generating bundle ✅`);
-        logger.info(`Adding bundled resources`);
+        logger.timeEnd(`Generating bundle`);
+        logger.time(`Adding bundled resources`);
         await (0, apktool_1.addBundleAssetsToDecodedApkAsync)({
             decodedApkRoot,
             assetRoot,
             bundleOutputPath,
         });
-        logger.info(`Finished adding bundled resources ✅`);
+        logger.timeEnd(`Adding bundled resources`);
     }
-    logger.info(`Updating Androidmanifest.xml`);
+    logger.time(`Updating Androidmanifest.xml`);
     const androidManiestFilePath = node_path_1.default.join(decodedApkRoot, 'AndroidManifest.xml');
     const androidManiestXml = await (0, resources_1.parseXmlFileAsync)(androidManiestFilePath);
     const originalAppId = await (0, resources_1.queryAppIdFromManifestAsync)(androidManiestXml);
-    const dexClasses = await (0, build_tools_1.searchDexClassesAsync)(decodedApkRoot, originalAppId);
+    const dexClasses = await (0, build_tools_1.searchDexClassesAsync)(decodedApkRoot, originalAppId, options);
     await (0, resources_1.updateAndroidManifestAsync)({
         config: exp,
         androidManiestXml,
@@ -58,19 +57,19 @@ async function repackAppAndroidAsync(_options) {
     });
     await (0, apktool_1.addRenameManifestPackageAsync)(decodedApkRoot, exp.android?.package);
     await (0, resources_1.buildXmlFileAsync)(androidManiestXml, androidManiestFilePath);
-    logger.info(`Finished updating Androidmanifest.xml ✅`);
-    logger.info(`Updating resources`);
+    logger.timeEnd(`Updating Androidmanifest.xml`);
+    logger.time(`Updating resources`);
     await (0, resources_1.updateResourcesAsync)({ config: exp, decodedApkRoot });
-    logger.info(`Finished updating resources ✅`);
-    logger.info(`Generating app config`);
+    logger.timeEnd(`Updating resources`);
+    logger.time(`Generating app config`);
     const appConfigPath = await (0, expo_1.generateAppConfigAsync)(options, exp);
     await promises_1.default.copyFile(appConfigPath, node_path_1.default.join(decodedApkRoot, 'assets', 'app.config'));
-    logger.info(`Finished generating app config ✅`);
-    logger.info(`Creating updated apk`);
+    logger.timeEnd(`Generating app config`);
+    logger.time(`Creating updated apk`);
     const apktoolPackedApkPath = await (0, apktool_1.rebuildApkAsync)(decodedApkRoot, options);
     const unzippedApkRoot = node_path_1.default.join(workingDirectory, 'unzip');
     await promises_1.default.mkdir(unzippedApkRoot, { recursive: true });
-    await (0, steps_1.spawnAsync)('unzip', ['-o', apktoolPackedApkPath, '-d', unzippedApkRoot], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await spawnAsync('unzip', ['-o', apktoolPackedApkPath, '-d', unzippedApkRoot]);
     const outputApk = await (0, build_tools_1.createResignedApkAsync)(unzippedApkRoot, options, {
         keyStorePath: options.androidSigningOptions?.keyStorePath ??
             node_path_1.default.resolve(__dirname, '../../assets/debug.keystore'),
@@ -78,7 +77,7 @@ async function repackAppAndroidAsync(_options) {
         keyAlias: options.androidSigningOptions?.keyAlias,
         keyPassword: options.androidSigningOptions?.keyPassword,
     });
-    logger.info(`Finished creating updated apk ✅`);
+    logger.timeEnd(`Creating updated apk`);
     await promises_1.default.rename(outputApk, options.outputPath);
     if (!options.skipWorkingDirCleanup) {
         try {

package/build/cli.js

@@ -3,16 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("@expo/logger");
 const commander_1 = require("commander");
 const picocolors_1 = __importDefault(require("picocolors"));
 const index_1 = require("./index");
+const utils_1 = require("./utils");
 const program = new commander_1.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')
+    .option('-o, --output <path>', 'Path to the output artifact')
     // Android signing options
     .option('--ks <path>', 'Path to the keystore file')
     .option('--ks-pass <password>', 'Keystore password', 'pass:android')
@@ -26,12 +26,13 @@ const program = new commander_1.Command('repack-app')
     .option('--embed-bundle-assets', 'Whether to execute export:embed to embed new bundle assets')
     .option('--bundle-assets-sourcemap-output <path>', 'Paired with --embed-bundle-assets and generate the sourcemap to the specified path')
     // arguments
-    .argument('<project-root>', 'Path to the project root')
+    .argument('[project-root]', 'Path to the project root', process.cwd())
+    .version(require('../package.json').version)
     .parse(process.argv);
 async function runAsync() {
-    const logger = (0, logger_1.createLogger)({ name: 'repack-app' });
+    const logger = new utils_1.ConsoleLogger();
     const platform = program.opts().platform;
-    const projectRoot = program.args[0];
+    const projectRoot = program.processedArgs[0];
     const exportEmbedOptions = program.opts()
         .embedBundleAssets
         ? {

package/build/expo.js

@@ -8,7 +8,6 @@ exports.isExpoUpdatesInstalled = isExpoUpdatesInstalled;
 exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;
 exports.getExpoConfig = getExpoConfig;
 exports.generateBundleAssetsAsync = generateBundleAssetsAsync;
-const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -36,13 +35,13 @@ function isExpoUpdatesInstalled(projectRoot) {
  * Resolve the `runtimeVersion` for expo-updates.
  */
 async function resolveRuntimeVersionAsync(options, config) {
-    const { projectRoot } = options;
+    const { projectRoot, spawnAsync } = options;
     const cli = resolve_from_1.default.silent(projectRoot, 'expo-updates/bin/cli') ??
         (0, resolve_from_1.default)(projectRoot, 'expo-updates/bin/cli.js');
-    const proc = await (0, steps_1.spawnAsync)(cli, ['runtimeversion:resolve', '--platform', 'android', '--workflow', 'managed'], {
+    const { stdout } = await spawnAsync(cli, ['runtimeversion:resolve', '--platform', 'android', '--workflow', 'managed'], {
         cwd: projectRoot,
     });
-    const runtimeVersion = JSON.parse(proc.stdout).runtimeVersion;
+    const runtimeVersion = JSON.parse(stdout).runtimeVersion;
     return runtimeVersion ?? config.version ?? '1.0.0';
 }
 /**
@@ -69,11 +68,11 @@ function getExpoConfig(projectRoot, options) {
  * Generate JS bundle and assets for the app.
  */
 async function generateBundleAssetsAsync(expoConfig, options) {
-    const { projectRoot, platform, workingDirectory } = options;
+    const { projectRoot, platform, spawnAsync, workingDirectory } = options;
     const bundleAssetRoot = node_path_1.default.resolve(workingDirectory, 'bundles');
     await promises_1.default.mkdir(bundleAssetRoot, { recursive: true });
     // [0] Resolve entry point
-    const { stdout: entryFile } = await (0, steps_1.spawnAsync)('node', ['-e', "require('expo/scripts/resolveAppEntry')", projectRoot, platform, 'absolute'], { cwd: projectRoot });
+    const { stdout: entryFile } = await spawnAsync('node', ['-e', "require('expo/scripts/resolveAppEntry')", projectRoot, platform, 'absolute'], { cwd: projectRoot });
     // [1] Execute export:embed
     const isEnableHermes = isEnableHermesManaged(expoConfig, platform);
     const bundleFileName = platform === 'android' ? 'index.android.bundle' : 'main.bundle';
@@ -96,7 +95,7 @@ async function generateBundleAssetsAsync(expoConfig, options) {
     ];
     if (isEnableHermes) {
         exportEmbedArgs.push('--minify', 'false');
-        exportEmbedArgs.push('--bundle-bytecode', 'true');
+        exportEmbedArgs.push('--bytecode', 'true');
         exportEmbedArgs.push('--unstable-transform-profile', 'hermes');
     }
     else {
@@ -105,9 +104,7 @@ async function generateBundleAssetsAsync(expoConfig, options) {
     if (options.exportEmbedOptions?.sourcemapOutput) {
         exportEmbedArgs.push('--sourcemap-output', options.exportEmbedOptions.sourcemapOutput);
     }
-    await (0, steps_1.spawnAsync)('npx', exportEmbedArgs, options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: projectRoot }
-        : { cwd: projectRoot });
+    await spawnAsync('npx', exportEmbedArgs, { cwd: projectRoot });
     return {
         bundleOutputPath,
         assetRoot,

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

@@ -1,13 +1,17 @@
 import { type ExpoConfig } from '@expo/config';
 import type { IosSigningOptions, NormalizedOptions } from '../types';
 /**
- * Unzip the IPA file.
+ * Extract the given iOS artifact and return the path to the .app directory.
  */
-export declare function unzipIpaAsync(options: NormalizedOptions): Promise<string>;
+export declare function extractIosArtifactAsync(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 .app directory.
+ */
+export declare function createAppAsync(options: NormalizedOptions, appWorkingDirectory: string): Promise<string>;
 /**
  * From the given working .app directory, create a new .ipa file.
  */

package/build/ios/build-tools.js

@@ -3,48 +3,73 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unzipIpaAsync = unzipIpaAsync;
+exports.extractIosArtifactAsync = extractIosArtifactAsync;
 exports.updateFilesAsync = updateFilesAsync;
+exports.createAppAsync = createAppAsync;
 exports.createIpaAsync = createIpaAsync;
 exports.createResignLane = createResignLane;
-const steps_1 = require("@expo/steps");
+const glob_1 = require("glob");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const utils_1 = require("../utils");
 /**
- * Unzip the IPA file.
+ * Extract the given iOS artifact and return the path to the .app directory.
  */
-async function unzipIpaAsync(options) {
-    const unzipWorkingDirectory = node_path_1.default.join(options.workingDirectory, 'unzip');
-    await (0, steps_1.spawnAsync)('unzip', [options.sourceAppPath, '-d', unzipWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-    const appWorkingDirectory = node_path_1.default.join(unzipWorkingDirectory, 'Payload', 'HelloWorld.app');
-    (0, node_assert_1.default)(await (0, utils_1.directoryExistsAsync)(appWorkingDirectory));
+async function extractIosArtifactAsync(options) {
+    const { spawnAsync, sourceAppPath } = options;
+    const extractedWorkingDirectory = node_path_1.default.join(options.workingDirectory, 'extracted');
+    await promises_1.default.mkdir(extractedWorkingDirectory, { recursive: true });
+    if (sourceAppPath.endsWith('.zip') || sourceAppPath.endsWith('.ipa')) {
+        await spawnAsync('unzip', [sourceAppPath, '-d', extractedWorkingDirectory]);
+    }
+    else if (sourceAppPath.endsWith('.tar.gz')) {
+        await spawnAsync('tar', ['-xzf', sourceAppPath, '-C', extractedWorkingDirectory]);
+    }
+    else if (sourceAppPath.endsWith('.app')) {
+        const basename = node_path_1.default.basename(sourceAppPath);
+        await (0, utils_1.copyDirAsync)(sourceAppPath, node_path_1.default.join(extractedWorkingDirectory, basename));
+    }
+    else {
+        throw new Error('Unsupported file type. Please provide a .zip, .tar.gz, or .app file.');
+    }
+    const matches = await (0, glob_1.glob)('{Payload/*.app,*.app}', {
+        cwd: extractedWorkingDirectory,
+        absolute: true,
+    });
+    const appWorkingDirectory = matches[0];
+    (0, node_assert_1.default)(appWorkingDirectory, `Failed to find the .app directory in the extracted artifact: ${extractedWorkingDirectory}`);
     return appWorkingDirectory;
 }
 /**
  * Update some binary files.
  */
 async function updateFilesAsync(config, appWorkingDirectory) {
-    const parentDir = node_path_1.default.dirname(appWorkingDirectory);
+    const { dir: parentDir, name } = node_path_1.default.parse(appWorkingDirectory);
     const newAppWorkingDirectory = node_path_1.default.join(parentDir, `${config.name}.app`);
     // [0] Update the .app directory
-    await promises_1.default.rename(node_path_1.default.join(parentDir, 'HelloWorld.app'), newAppWorkingDirectory);
+    await promises_1.default.rename(node_path_1.default.join(parentDir, `${name}.app`), newAppWorkingDirectory);
     // [1] Rename the executable
-    await promises_1.default.rename(node_path_1.default.join(newAppWorkingDirectory, 'HelloWorld'), node_path_1.default.join(newAppWorkingDirectory, config.name));
+    await promises_1.default.rename(node_path_1.default.join(newAppWorkingDirectory, name), node_path_1.default.join(newAppWorkingDirectory, config.name));
     return newAppWorkingDirectory;
 }
+/**
+ * From the given working .app directory, create a new .app directory.
+ */
+async function createAppAsync(options, appWorkingDirectory) {
+    const outputAppPath = node_path_1.default.resolve(options.workingDirectory, node_path_1.default.basename(appWorkingDirectory));
+    await (0, utils_1.copyDirAsync)(appWorkingDirectory, outputAppPath);
+    return outputAppPath;
+}
 /**
  * From the given working .app directory, create a new .ipa file.
  */
 async function createIpaAsync(options, appWorkingDirectory) {
-    const { workingDirectory } = options;
+    const { spawnAsync, workingDirectory } = options;
     await promises_1.default.mkdir(node_path_1.default.join(workingDirectory, 'Payload'), { recursive: true });
     await promises_1.default.rename(appWorkingDirectory, node_path_1.default.join(workingDirectory, 'Payload', node_path_1.default.basename(appWorkingDirectory)));
     const outputIpaPath = node_path_1.default.resolve(workingDirectory, 'repacked.ipa');
-    await (0, steps_1.spawnAsync)('zip', ['-r', outputIpaPath, 'Payload'], options.verbose
-        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
-        : { cwd: workingDirectory });
+    await spawnAsync('zip', ['-r', outputIpaPath, 'Payload'], { cwd: workingDirectory });
     return outputIpaPath;
 }
 /**

package/build/ios/index.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repackAppIosAsync = repackAppIosAsync;
 exports.resignIpaAsync = resignIpaAsync;
-const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -30,43 +29,50 @@ async function repackAppIosAsync(_options) {
         ? await (0, expo_1.resolveRuntimeVersionAsync)(options, exp)
         : null;
     logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
-    logger.info(`Unzipping IPA`);
-    let appWorkingDirectory = await (0, build_tools_1.unzipIpaAsync)(options);
+    logger.time(`Extracting artifact from ${options.sourceAppPath}`);
+    let appWorkingDirectory = await (0, build_tools_1.extractIosArtifactAsync)(options);
     appWorkingDirectory = await (0, build_tools_1.updateFilesAsync)(exp, appWorkingDirectory);
     const infoPlistPath = node_path_1.default.join(appWorkingDirectory, 'Info.plist');
     const originalAppId = await (0, resources_1.queryAppIdFromPlistAsync)(infoPlistPath, options);
-    logger.info(`Finished unzipping IPA ✅`);
+    logger.timeEnd(`Extracting artifact from ${options.sourceAppPath}`);
     if (options.exportEmbedOptions != null) {
-        logger.info(`Generating bundle`);
+        logger.time(`Generating bundle`);
         const { assetRoot, bundleOutputPath } = await (0, expo_1.generateBundleAssetsAsync)(exp, options);
-        logger.info(`Finished generating bundle ✅`);
-        logger.info(`Adding bundled resources`);
+        logger.timeEnd(`Generating bundle`);
+        logger.time(`Adding bundled resources`);
         await (0, resources_1.addBundleAssetsAsync)({
             appWorkingDirectory,
             assetRoot,
             bundleOutputPath,
         });
-        logger.info(`Finished adding bundled resources ✅`);
+        logger.timeEnd(`Adding bundled resources`);
     }
-    logger.info(`Updating Info.plist`);
+    logger.time(`Updating Info.plist`);
     await (0, resources_1.updateInfoPlistAsync)({ config: exp, infoPlistPath, originalAppId, options });
-    logger.info(`Finished updating Info.plist ✅`);
-    logger.info(`Updating Expo.plist`);
+    logger.timeEnd(`Updating Info.plist`);
+    logger.time(`Updating Expo.plist`);
     await (0, resources_1.updateExpoPlistAsync)(exp, node_path_1.default.join(appWorkingDirectory, 'Expo.plist'), updatesRuntimeVersion, options);
-    logger.info(`Finished updating Expo.plist ✅`);
-    logger.info(`Generating app.config`);
+    logger.timeEnd(`Updating Expo.plist`);
+    logger.time(`Generating app.config`);
     const appConfigPath = await (0, expo_1.generateAppConfigAsync)(options, exp);
     await promises_1.default.copyFile(appConfigPath, node_path_1.default.join(appWorkingDirectory, 'EXConstants.bundle', 'app.config'));
-    logger.info(`Finished generating app.config ✅`);
-    logger.info(`Creating updated ipa`);
-    const outputIpa = await (0, build_tools_1.createIpaAsync)(options, appWorkingDirectory);
-    logger.info(`Finished creating updated ipa ✅`);
+    logger.timeEnd(`Generating app.config`);
+    logger.time(`Creating updated artifact`);
+    let outputArtifact;
+    if (options.outputPath.endsWith('.app')) {
+        outputArtifact = await (0, build_tools_1.createAppAsync)(options, appWorkingDirectory);
+    }
+    else {
+        outputArtifact = await (0, build_tools_1.createIpaAsync)(options, appWorkingDirectory);
+    }
+    logger.timeEnd(`Creating updated artifact`);
     if (options.iosSigningOptions) {
-        logger.info(`Resigning the IPA at ${outputIpa}`);
-        await resignIpaAsync(outputIpa, options.iosSigningOptions, options);
-        logger.info(`Finished resigning the IPA ✅`);
+        (0, node_assert_1.default)(outputArtifact.endsWith('.ipa'), 'Signing is only supported for .ipa files');
+        logger.time(`Resigning the IPA at ${outputArtifact}`);
+        await resignIpaAsync(outputArtifact, options.iosSigningOptions, options);
+        logger.timeEnd(`Resigning the IPA at ${outputArtifact}`);
     }
-    await promises_1.default.rename(outputIpa, options.outputPath);
+    await promises_1.default.rename(outputArtifact, options.outputPath);
     if (!options.skipWorkingDirCleanup) {
         try {
             await promises_1.default.rm(workingDirectory, { recursive: true });
@@ -80,13 +86,12 @@ async function repackAppIosAsync(_options) {
  */
 async function resignIpaAsync(ipaPath, signingOptions, _options) {
     const options = await (0, utils_1.normalizeOptionAsync)(_options);
+    const { spawnAsync } = options;
     const resignWorkingDirectory = node_path_1.default.join(options.workingDirectory, 'fastlane');
     await promises_1.default.mkdir(resignWorkingDirectory, { recursive: true });
     const fastfileContents = (0, build_tools_1.createResignLane)('resign_ipa', ipaPath, signingOptions);
     await promises_1.default.writeFile(node_path_1.default.join(resignWorkingDirectory, 'Fastfile'), fastfileContents);
-    await (0, steps_1.spawnAsync)('fastlane', ['resign_ipa'], {
-        logger: options.logger,
-        stdio: 'pipe',
+    await spawnAsync('fastlane', ['resign_ipa'], {
         cwd: resignWorkingDirectory,
         env: options.env,
     });

package/build/ios/resources.js

@@ -8,7 +8,6 @@ exports.updateExpoPlistAsync = updateExpoPlistAsync;
 exports.queryAppIdFromPlistAsync = queryAppIdFromPlistAsync;
 exports.addBundleAssetsAsync = addBundleAssetsAsync;
 const plist_1 = __importDefault(require("@expo/plist"));
-const steps_1 = require("@expo/steps");
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -36,15 +35,18 @@ async function updateInfoPlistAsync({ config, infoPlistPath, originalAppId, opti
                 urlType.CFBundleURLSchemes = schemes;
             }
         }
-        const userActivityTypes = data.NSUserActivityTypes.map((activityType) => activityType.replace(originalAppId, bundleIdentifier));
-        return {
+        const result = {
             ...data,
             CFBundleDisplayName: config.name,
             CFBundleName: config.name,
             CFBundleExecutable: config.name,
             CFBundleIdentifier: bundleIdentifier,
-            NSUserActivityTypes: userActivityTypes,
         };
+        const userActivityTypes = data.NSUserActivityTypes?.map((activityType) => activityType.replace(originalAppId, bundleIdentifier));
+        if (userActivityTypes) {
+            result.NSUserActivityTypes = userActivityTypes;
+        }
+        return result;
     });
 }
 /**
@@ -88,30 +90,17 @@ async function addBundleAssetsAsync({ appWorkingDirectory, assetRoot, bundleOutp
     await promises_1.default.copyFile(bundleOutputPath, node_path_1.default.join(appWorkingDirectory, 'main.jsbundle'));
     // export:embed --assets-dest on iOS uses the app root as target directory,
     // so we just need to copy the assets to the app root.
-    await copyDirAsync(assetRoot, appWorkingDirectory);
+    await (0, utils_1.copyDirAsync)(assetRoot, appWorkingDirectory);
 }
 //#region Internals
 async function updateBinaryPlistAsync(plistPath, options, updater) {
-    await (0, steps_1.spawnAsync)('plutil', ['-convert', 'xml1', plistPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    const { spawnAsync } = options;
+    await spawnAsync('plutil', ['-convert', 'xml1', plistPath]);
     const contents = await promises_1.default.readFile(plistPath, 'utf8');
     const data = await plist_1.default.parse(contents);
     const updatedData = updater(data);
     const updatedContents = plist_1.default.build(updatedData);
     await promises_1.default.writeFile(plistPath, updatedContents);
-    await (0, steps_1.spawnAsync)('plutil', ['-convert', 'binary1', plistPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
-}
-async function copyDirAsync(src, dst) {
-    await promises_1.default.mkdir(dst, { recursive: true });
-    const entries = await promises_1.default.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = node_path_1.default.join(src, entry.name);
-        const dstPath = node_path_1.default.join(dst, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirAsync(srcPath, dstPath);
-        }
-        else if (entry.isFile()) {
-            await promises_1.default.copyFile(srcPath, dstPath);
-        }
-    }
+    await spawnAsync('plutil', ['-convert', 'binary1', plistPath]);
 }
 //#endregion

package/build/types.d.ts

@@ -1,4 +1,4 @@
-import type { bunyan } from '@expo/logger';
+import type { ChildProcess, SpawnOptions } from 'child_process';
 export interface Options {
     /**
      * The platform to repack the app for.
@@ -12,10 +12,6 @@ export interface Options {
      * The prebuilt app file path that acts as a source for repacking.
      */
     sourceAppPath: string;
-    /**
-     * The bunyan logger instance.
-     */
-    logger: bunyan;
     /**
      * Working directory.
      */
@@ -54,10 +50,22 @@ export interface Options {
      * env variables
      */
     env?: Record<string, string | undefined>;
+    /**
+     * Customize the logger instance.
+     * @default `console`
+     */
+    logger?: Logger;
+    /**
+     * Customize the spawn process function.
+     * @default `@expo/spawn-async`
+     */
+    spawnAsync?: SpawnProcessAsync;
 }
 export interface NormalizedOptions extends Options {
     workingDirectory: NonNullable<Options['workingDirectory']>;
     outputPath: NonNullable<Options['outputPath']>;
+    logger: NonNullable<Options['logger']>;
+    spawnAsync: NonNullable<Options['spawnAsync']>;
 }
 export interface AndroidSigningOptions {
     /**
@@ -109,3 +117,27 @@ export interface ExportEmbedOptions {
      */
     sourcemapOutput?: string;
 }
+export interface Logger {
+    debug(...message: any[]): void;
+    info(...message: any[]): void;
+    warn(...message: any[]): void;
+    error(...message: any[]): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+export interface SpawnProcessOptions extends SpawnOptions {
+}
+export interface SpawnProcessPromise<T> extends Promise<T> {
+    child: ChildProcess;
+}
+export interface SpawnProcessResult {
+    pid?: number;
+    output: string[];
+    stdout: string;
+    stderr: string;
+    status: number | null;
+    signal: string | null;
+}
+export interface SpawnProcessAsync {
+    (command: string, args: string[], options?: SpawnProcessOptions): SpawnProcessPromise<SpawnProcessResult>;
+}

package/build/types.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//#endregion Advanced integrations

package/build/utils.d.ts

@@ -1,4 +1,4 @@
-import type { NormalizedOptions, Options } from './types';
+import type { Logger, NormalizedOptions, Options } from './types';
 /**
  * Check if a directory exists.
  */
@@ -11,3 +11,15 @@ export declare function requireNotNull<T>(value: T | null | undefined): T;
  * Normalize the options.
  */
 export declare function normalizeOptionAsync(options: Options): Promise<NormalizedOptions>;
+export declare class ConsoleLogger implements Logger {
+    debug(...message: any[]): void;
+    info(...message: any[]): void;
+    warn(...message: any[]): void;
+    error(...message: any[]): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+/**
+ * Copy a directory recursively.
+ */
+export declare function copyDirAsync(src: string, dst: string): Promise<void>;

package/build/utils.js

@@ -3,9 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
 exports.directoryExistsAsync = directoryExistsAsync;
 exports.requireNotNull = requireNotNull;
 exports.normalizeOptionAsync = normalizeOptionAsync;
+exports.copyDirAsync = copyDirAsync;
+const spawn_async_1 = __importDefault(require("@expo/spawn-async"));
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -31,5 +34,53 @@ async function normalizeOptionAsync(options) {
         ...options,
         workingDirectory: options.workingDirectory ?? (await promises_1.default.mkdtemp(node_path_1.default.join(require('temp-dir'), 'repack-app-'))),
         outputPath: options.outputPath ?? node_path_1.default.join(options.projectRoot, `repacked${fileExt}`),
+        logger: options.logger ?? new ConsoleLogger(),
+        spawnAsync: options.spawnAsync ?? createDefaultSpawnAsync(!!options.verbose),
     };
 }
+class ConsoleLogger {
+    debug(...message) {
+        console.debug(...message);
+    }
+    info(...message) {
+        console.log(...message);
+    }
+    warn(...message) {
+        console.warn(...message);
+    }
+    error(...message) {
+        console.error(...message);
+    }
+    time(label) {
+        console.time(label);
+    }
+    timeEnd(label) {
+        console.timeEnd(label);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+function createDefaultSpawnAsync(verbose) {
+    return function defaultSpawnAsync(command, args, options) {
+        return (0, spawn_async_1.default)(command, args, {
+            stdio: verbose ? 'inherit' : 'pipe',
+            ...options,
+        });
+    };
+}
+/**
+ * Copy a directory recursively.
+ */
+async function copyDirAsync(src, dst) {
+    await promises_1.default.mkdir(dst, { recursive: true });
+    const entries = await promises_1.default.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = node_path_1.default.join(src, entry.name);
+        const dstPath = node_path_1.default.join(dst, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirAsync(srcPath, dstPath);
+        }
+        else if (entry.isFile()) {
+            await promises_1.default.copyFile(srcPath, dstPath);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/repack-app",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Repacking tool for Expo apps",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,9 +25,8 @@
   "author": "650 Industries, Inc.",
   "license": "BUSL-1.1",
   "dependencies": {
-    "@expo/logger": "^1.0.117",
     "@expo/plist": "^0.2.0",
-    "@expo/steps": "^1.0.156",
+    "@expo/spawn-async": "^1.7.2",
     "commander": "^13.0.0",
     "glob": "^11.0.0",
     "picocolors": "^1.1.1",