@expo/repack-app 0.1.4 → 0.1.6

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;
 }
 /**
@@ -66,7 +73,7 @@ async function getApktoolPathAsync() {
     }
     return cachedApktoolPath;
 }
-async function addApktoolResourceAsync(decodedApkRoot, assetSet) {
+async function addApktoolResourceAsync(decodedApkRoot, assetMap) {
     const apktoolPublicXmlPath = node_path_1.default.join(decodedApkRoot, 'res/values/public.xml');
     // [0] Retrieve the current max resource ID and the existing drawable names
     const contents = await promises_1.default.readFile(apktoolPublicXmlPath, 'utf8');
@@ -97,8 +104,12 @@ async function addApktoolResourceAsync(decodedApkRoot, assetSet) {
     }
     const drawableResIdBoundary = (maxDrawableResId & 0xffff0000) + 0x10000;
     const rawResIdBoundary = (maxRawResId & 0xffff0000) + 0x10000;
-    const newAssetSet = new Set([...assetSet].filter(({ name }) => !existingNameSet.has(name)));
-    for (const asset of newAssetSet) {
+    const newAssetNameSet = new Set([...assetMap.keys()].filter((name) => !existingNameSet.has(name)));
+    for (const assetName of newAssetNameSet) {
+        const asset = assetMap.get(assetName);
+        if (asset == null) {
+            continue;
+        }
         if (asset.type === 'drawable') {
             maxDrawableResId += 1;
             (0, node_assert_1.default)(maxDrawableResId < drawableResIdBoundary, 'Drawable resource ID boundary exceeded.');
@@ -136,7 +147,7 @@ function getAssetType(name) {
  * @param level The current depth level (starts at 0).
  * @param maxLevel The maximum depth level to process.
  */
-async function copyAssetsAsync(src, dest, level = 0, maxLevel = 2, assetType = undefined, assetSet = new Set()) {
+async function copyAssetsAsync(src, dest, level = 0, maxLevel = 2, assetType = undefined, assetMap = new Map()) {
     await promises_1.default.mkdir(dest, { recursive: true });
     const entries = await promises_1.default.readdir(src, { withFileTypes: true });
     await Promise.all(entries.map(async (entry) => {
@@ -145,7 +156,7 @@ async function copyAssetsAsync(src, dest, level = 0, maxLevel = 2, assetType = u
         if (entry.isDirectory()) {
             const _assetType = assetType ?? getAssetType(entry.name);
             if (level < maxLevel - 1) {
-                await copyAssetsAsync(srcPath, destPath, level + 1, maxLevel, _assetType, assetSet);
+                await copyAssetsAsync(srcPath, destPath, level + 1, maxLevel, _assetType, assetMap);
             }
             else {
                 // When the maximum level is reached, copy the directory without further recursion
@@ -156,9 +167,9 @@ async function copyAssetsAsync(src, dest, level = 0, maxLevel = 2, assetType = u
             await promises_1.default.copyFile(srcPath, destPath);
             const { name } = node_path_1.default.parse(entry.name);
             (0, node_assert_1.default)(assetType, 'Asset type must be defined.');
-            assetSet.add({ name, type: assetType });
+            assetMap.set(name, { name, type: assetType });
         }
     }));
-    return assetSet;
+    return assetMap;
 }
 //#endregion Internals

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,12 +98,14 @@ 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,
+        stdio: 'pipe',
     });
     const classes = stdout
         .split('\n')

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,
@@ -27,27 +26,35 @@ async function repackAppAndroidAsync(_options) {
     });
     const decodedApkRoot = await (0, apktool_1.decodeApkAsync)(node_path_1.default.resolve(options.sourceAppPath), options);
     (0, node_assert_1.default)(exp.android?.package, 'Expected app ID (`android.package`) to be defined in app.json');
-    const updatesRuntimeVersion = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot)
+    const useExpoUpdates = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot);
+    const updatesRuntimeVersion = useExpoUpdates
         ? await (0, expo_1.resolveRuntimeVersionAsync)(options, exp)
         : 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`);
+        if (useExpoUpdates) {
+            logger.time(`Generating 'app.manifest' for expo-updates`);
+            const updateManifestFile = await (0, expo_1.generateUpdatesEmbeddedManifestAsync)(options);
+            const updateDirectory = node_path_1.default.join(decodedApkRoot, 'assets');
+            await promises_1.default.copyFile(updateManifestFile, node_path_1.default.join(updateDirectory, node_path_1.default.basename(updateManifestFile)));
+            logger.timeEnd(`Generating 'app.manifest' for expo-updates`);
+        }
     }
-    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 +65,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 +85,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,10 +3,10 @@ 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')
@@ -30,7 +30,7 @@ const program = new commander_1.Command('repack-app')
     .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.processedArgs[0];
     const exportEmbedOptions = program.opts()

package/build/expo.d.ts

@@ -4,6 +4,10 @@ import type { NormalizedOptions } from './types';
  * Generate the app.config file for the Android app.
  */
 export declare function generateAppConfigAsync(options: NormalizedOptions, config: ExpoConfig): Promise<string>;
+/**
+ * Generate the embedded `app.manifest` for expo-updates
+ */
+export declare function generateUpdatesEmbeddedManifestAsync(options: NormalizedOptions): Promise<string>;
 /**
  * Returns whether expo-updates is installed in the project.
  */

package/build/expo.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAppConfigAsync = generateAppConfigAsync;
+exports.generateUpdatesEmbeddedManifestAsync = generateUpdatesEmbeddedManifestAsync;
 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"));
@@ -22,6 +22,21 @@ async function generateAppConfigAsync(options, config) {
     await promises_1.default.writeFile(appConfigPath, JSON.stringify(config));
     return appConfigPath;
 }
+/**
+ * Generate the embedded `app.manifest` for expo-updates
+ */
+async function generateUpdatesEmbeddedManifestAsync(options) {
+    const { platform, projectRoot, spawnAsync, workingDirectory } = options;
+    // [0] Resolve entry point
+    const { stdout: entryFile } = await spawnAsync('node', ['-e', "require('expo/scripts/resolveAppEntry')", projectRoot, platform, 'absolute'], { cwd: projectRoot, stdio: 'pipe' });
+    // [1] Generate the `app.manifest` file
+    const binPath = resolve_from_1.default.silent(options.projectRoot, 'expo-updates/utils/build/createUpdatesResources.js');
+    (0, node_assert_1.default)(binPath, 'Failed to resolve `createUpdatesResources.js` within expo-updates package');
+    await spawnAsync('node', [binPath, platform, projectRoot, workingDirectory, 'all', entryFile.trim()], {
+        cwd: projectRoot,
+    });
+    return node_path_1.default.join(workingDirectory, 'app.manifest');
+}
 /**
  * Returns whether expo-updates is installed in the project.
  */
@@ -36,13 +51,14 @@ 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,
+        stdio: 'pipe',
     });
-    const runtimeVersion = JSON.parse(proc.stdout).runtimeVersion;
+    const runtimeVersion = JSON.parse(stdout).runtimeVersion;
     return runtimeVersion ?? config.version ?? '1.0.0';
 }
 /**
@@ -69,11 +85,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, stdio: 'pipe' });
     // [1] Execute export:embed
     const isEnableHermes = isEnableHermesManaged(expoConfig, platform);
     const bundleFileName = platform === 'android' ? 'index.android.bundle' : 'main.bundle';
@@ -96,7 +112,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 +121,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.js

@@ -8,7 +8,6 @@ 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"));
@@ -18,14 +17,14 @@ const utils_1 = require("../utils");
  * Extract the given iOS artifact and return the path to the .app directory.
  */
 async function extractIosArtifactAsync(options) {
-    const { sourceAppPath } = 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 (0, steps_1.spawnAsync)('unzip', [sourceAppPath, '-d', extractedWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+        await spawnAsync('unzip', [sourceAppPath, '-d', extractedWorkingDirectory]);
     }
     else if (sourceAppPath.endsWith('.tar.gz')) {
-        await (0, steps_1.spawnAsync)('tar', ['-xzf', sourceAppPath, '-C', extractedWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+        await spawnAsync('tar', ['-xzf', sourceAppPath, '-C', extractedWorkingDirectory]);
     }
     else if (sourceAppPath.endsWith('.app')) {
         const basename = node_path_1.default.basename(sourceAppPath);
@@ -66,13 +65,11 @@ async function createAppAsync(options, appWorkingDirectory) {
  * 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"));
@@ -26,39 +25,50 @@ async function repackAppIosAsync(_options) {
         skipSDKVersionRequirement: true,
     });
     (0, node_assert_1.default)(exp.ios?.bundleIdentifier, 'Expected app ID (`ios.bundleIdentifier`) to be defined in app.json');
-    const updatesRuntimeVersion = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot)
+    const useExpoUpdates = (0, expo_1.isExpoUpdatesInstalled)(options.projectRoot);
+    const updatesRuntimeVersion = useExpoUpdates
         ? await (0, expo_1.resolveRuntimeVersionAsync)(options, exp)
         : null;
-    logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
-    logger.info(`Extracting artifact from ${options.sourceAppPath}`);
+    if (useExpoUpdates) {
+        logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
+    }
+    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 extracting artifact from ${options.sourceAppPath} ✅`);
+    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`);
+        if (useExpoUpdates) {
+            logger.time(`Generating 'app.manifest' for expo-updates`);
+            const updateManifestFile = await (0, expo_1.generateUpdatesEmbeddedManifestAsync)(options);
+            const updateDirectory = node_path_1.default.join(appWorkingDirectory, 'EXUpdates.bundle');
+            (0, node_assert_1.default)(await (0, utils_1.directoryExistsAsync)(updateDirectory), 'Expected EXUpdates.bundle directory to exist');
+            await promises_1.default.copyFile(updateManifestFile, node_path_1.default.join(updateDirectory, node_path_1.default.basename(updateManifestFile)));
+            logger.timeEnd(`Generating 'app.manifest' for expo-updates`);
+        }
     }
-    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 artifact`);
+    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);
@@ -66,12 +76,12 @@ async function repackAppIosAsync(_options) {
     else {
         outputArtifact = await (0, build_tools_1.createIpaAsync)(options, appWorkingDirectory);
     }
-    logger.info(`Finished creating updated artifact ✅`);
+    logger.timeEnd(`Creating updated artifact`);
     if (options.iosSigningOptions) {
         (0, node_assert_1.default)(outputArtifact.endsWith('.ipa'), 'Signing is only supported for .ipa files');
-        logger.info(`Resigning the IPA at ${outputArtifact}`);
+        logger.time(`Resigning the IPA at ${outputArtifact}`);
         await resignIpaAsync(outputArtifact, options.iosSigningOptions, options);
-        logger.info(`Finished resigning the IPA ✅`);
+        logger.timeEnd(`Resigning the IPA at ${outputArtifact}`);
     }
     await promises_1.default.rename(outputArtifact, options.outputPath);
     if (!options.skipWorkingDirCleanup) {
@@ -87,13 +97,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;
     });
 }
 /**
@@ -92,12 +94,13 @@ async function addBundleAssetsAsync({ appWorkingDirectory, assetRoot, bundleOutp
 }
 //#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);
+    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,6 +11,14 @@ 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.
  */

package/build/utils.js

@@ -3,10 +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"));
@@ -32,6 +34,37 @@ 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,
+        });
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/repack-app",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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",