@expo/repack-app 0.0.3 → 0.0.5

package/build/android/Resources.types.js

@@ -1,4 +1,5 @@
+"use strict";
 /**
  * Types mapped from the Resoruces.proto file.
  */
-export {};
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,4 @@
-import type { AndroidSigningOptions, NormalizedOptions } from '../types.js';
+import type { AndroidSigningOptions, NormalizedOptions } from '../types';
 export interface AndroidTools {
     aapt2Path: string;
     apksignerPath: string;

package/build/android/build-tools.js

@@ -1,62 +1,65 @@
-import { glob } from 'glob';
-import assert from 'node:assert';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { spawnAsync } from '../cjs-wrapper.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLatestBuildToolsDirAsync = exports.createResignedApkAsync = exports.createBinaryBasedResourcesAsync = exports.createProtoBasedResourcesAsync = exports.getAndroidBuildToolsAsync = void 0;
+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"));
 let cachedAndroidTools = null;
 /**
  * Get the paths to the Android build-tools.
  */
-export async function getAndroidBuildToolsAsync(options) {
+async function getAndroidBuildToolsAsync(options) {
     if (cachedAndroidTools == null) {
         const androidBuildToolsDir = options?.androidBuildToolsDir ?? (await findLatestBuildToolsDirAsync());
-        assert(androidBuildToolsDir != null, 'Unable to find the Android build-tools directory.');
+        (0, node_assert_1.default)(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'),
+            aapt2Path: node_path_1.default.join(androidBuildToolsDir, 'aapt2'),
+            apksignerPath: node_path_1.default.join(androidBuildToolsDir, 'apksigner'),
+            zipalignPath: node_path_1.default.join(androidBuildToolsDir, 'zipalign'),
         };
     }
     return cachedAndroidTools;
 }
+exports.getAndroidBuildToolsAsync = getAndroidBuildToolsAsync;
 /**
  * Create an APK with proto-based resources.
  */
-export async function createProtoBasedResourcesAsync(options) {
+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('**/*', {
+    const protoApkPath = node_path_1.default.join(workingDirectory, 'proto.apk');
+    await (0, steps_1.spawnAsync)(aapt2Path, ['convert', '-o', protoApkPath, '--output-format', 'proto', '--keep-raw-values', sourceAppPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await (0, steps_1.spawnAsync)('unzip', [protoApkPath, '-d', workingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    const removeFiles = await (0, glob_1.glob)('**/*', {
         cwd: workingDirectory,
         maxDepth: 1,
         ignore: ['resources.pb', 'AndroidManifest.xml', 'res/**'],
         absolute: true,
     });
-    await Promise.all(removeFiles.map((file) => fs.rm(file, { recursive: true })));
+    await Promise.all(removeFiles.map((file) => promises_1.default.rm(file, { recursive: true })));
     return {
-        androidManiestFilePath: path.join(workingDirectory, 'AndroidManifest.xml'),
-        resourcesPbFilePath: path.join(workingDirectory, 'resources.pb'),
+        androidManiestFilePath: node_path_1.default.join(workingDirectory, 'AndroidManifest.xml'),
+        resourcesPbFilePath: node_path_1.default.join(workingDirectory, 'resources.pb'),
     };
 }
+exports.createProtoBasedResourcesAsync = createProtoBasedResourcesAsync;
 /**
  * Create an APK with binary-based resources.
  */
-export async function createBinaryBasedResourcesAsync(options) {
+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, [
+    const protoUpdatedApkPath = node_path_1.default.join(workingDirectory, 'proto-updated.apk');
+    const binaryApkPath = node_path_1.default.join(workingDirectory, 'binary.apk');
+    await (0, steps_1.spawnAsync)('zip', ['-r', '-0', protoUpdatedApkPath, 'resources.pb', 'AndroidManifest.xml', 'res'], options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
+        : { cwd: workingDirectory });
+    await (0, steps_1.spawnAsync)(aapt2Path, [
         'convert',
         '-o',
         binaryApkPath,
@@ -64,42 +67,33 @@ export async function createBinaryBasedResourcesAsync(options) {
         'binary',
         '--keep-raw-values',
         protoUpdatedApkPath,
-    ], {
-        stdio: options.verbose ? 'inherit' : 'ignore',
-    });
+    ], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
     return binaryApkPath;
 }
+exports.createBinaryBasedResourcesAsync = createBinaryBasedResourcesAsync;
 /**
  * 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) {
+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 unzipWorkingDirectory = node_path_1.default.join(workingDirectory, 'unzip');
+    const resignedApkPath = node_path_1.default.join(workingDirectory, 'resigned.apk');
+    const resignedApkUnalignedPath = node_path_1.default.join(workingDirectory, 'resigned-unaligned.apk');
+    await promises_1.default.mkdir(unzipWorkingDirectory, { recursive: true });
+    await (0, steps_1.spawnAsync)('unzip', [options.sourceAppPath, '-d', unzipWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await (0, steps_1.spawnAsync)('unzip', ['-o', binaryApkPath, '-d', unzipWorkingDirectory], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    await promises_1.default.copyFile(appConfigPath, node_path_1.default.join(unzipWorkingDirectory, 'assets', 'app.config'));
+    await (0, steps_1.spawnAsync)('zip', ['-r', '-0', resignedApkUnalignedPath, 'lib', 'resources.arsc'], options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: unzipWorkingDirectory }
+        : { cwd: unzipWorkingDirectory });
+    await (0, steps_1.spawnAsync)('zip', ['-r', resignedApkUnalignedPath, '.', '-x', 'lib/*', '-x', 'resources.arsc'], options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: unzipWorkingDirectory }
+        : { cwd: unzipWorkingDirectory });
+    await (0, steps_1.spawnAsync)(zipalignPath, ['-v', '-p', '4', resignedApkUnalignedPath, resignedApkPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
     const signerArgs = [
         'sign',
         '--ks',
@@ -114,20 +108,19 @@ export async function createResignedApkAsync(binaryApkPath, appConfigPath, optio
         signerArgs.push('--key-pass', signingOptions.keyPassword);
     }
     signerArgs.push(resignedApkPath);
-    await spawnAsync(apksignerPath, signerArgs, {
-        stdio: options.verbose ? 'inherit' : 'ignore',
-    });
+    await (0, steps_1.spawnAsync)(apksignerPath, signerArgs, options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
     return resignedApkPath;
 }
+exports.createResignedApkAsync = createResignedApkAsync;
 /**
  * Find the latest build-tools directory in the `ANDROID_SDK_ROOT` directory.
  */
-export async function findLatestBuildToolsDirAsync() {
+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');
+    (0, node_assert_1.default)(androidSdkRoot != null, 'ANDROID_SDK_ROOT environment variable is not set');
+    const buildToolsDir = node_path_1.default.join(androidSdkRoot, 'build-tools');
     try {
-        const entries = await fs.readdir(buildToolsDir, { withFileTypes: true });
+        const entries = await promises_1.default.readdir(buildToolsDir, { withFileTypes: true });
         const dirs = entries
             .filter((entry) => entry.isDirectory())
             .map((dir) => dir.name)
@@ -143,7 +136,7 @@ export async function findLatestBuildToolsDirAsync() {
             return versionB.length - versionA.length;
         });
         if (dirs.length > 0) {
-            return path.join(buildToolsDir, dirs[0]);
+            return node_path_1.default.join(buildToolsDir, dirs[0]);
         }
         else {
             console.error('No build-tools directories found.');
@@ -155,3 +148,4 @@ export async function findLatestBuildToolsDirAsync() {
         return null;
     }
 }
+exports.findLatestBuildToolsDirAsync = findLatestBuildToolsDirAsync;

package/build/android/index.d.ts

@@ -1,4 +1,4 @@
-import type { Options } from '../types.js';
+import type { Options } from '../types';
 /**
  * Repack an Android app.
  */

package/build/android/index.js

@@ -1,53 +1,61 @@
-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';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repackAppAndroidAsync = void 0;
+const config_1 = require("@expo/config");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const build_tools_1 = require("./build-tools");
+const resources_1 = require("./resources");
+const expo_1 = require("../expo");
+const utils_1 = require("../utils");
 /**
  * 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, {
+async function repackAppAndroidAsync(_options) {
+    const options = await (0, utils_1.normalizeOptionAsync)(_options);
+    const { workingDirectory, logger } = options;
+    await promises_1.default.mkdir(workingDirectory, { recursive: true });
+    const { exp } = (0, config_1.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, {
+    const updatesRuntimeVersion = await (0, expo_1.resolveRuntimeVersionAsync)(options, exp);
+    logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
+    logger.info(`Unzipping APK and creating proto based resources`);
+    const { androidManiestFilePath, resourcesPbFilePath } = await (0, build_tools_1.createProtoBasedResourcesAsync)(options);
+    logger.info(`Finished unzipping APK and creating proto based resources ✅`);
+    logger.info(`Updating Androidmanifest.xml`);
+    await (0, resources_1.updateAndroidManifestAsync)(exp, androidManiestFilePath, options, updatesRuntimeVersion);
+    logger.info(`Finished updating Androidmanifest.xml ✅`);
+    logger.info(`Updating resources.pb`);
+    await (0, resources_1.updateResourcesAsync)(exp, resourcesPbFilePath);
+    logger.info(`Finished updating resources.pb ✅`);
+    logger.info(`Creating binary based resources`);
+    const binaryApkPath = await (0, build_tools_1.createBinaryBasedResourcesAsync)(options);
+    logger.info(`Finished creating binary based resources ✅`);
+    logger.info(`Generating app config`);
+    const appConfigPath = await (0, expo_1.generateAppConfigAsync)(options, exp);
+    logger.info(`Finished generating app config ✅`);
+    logger.info(`Creating updated apk`);
+    const outputApk = await (0, build_tools_1.createResignedApkAsync)(binaryApkPath, appConfigPath, options, {
         keyStorePath: options.androidSigningOptions?.keyStorePath ??
-            path.resolve(import.meta.dirname, '../assets/debug.keystore'),
+            node_path_1.default.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 });
+    logger.info(`Finished creating updated apk ✅`);
+    await promises_1.default.rename(outputApk, options.outputPath);
+    if (!options.skipWorkingDirCleanup) {
+        try {
+            await promises_1.default.rmdir(workingDirectory, { recursive: true });
+        }
+        catch { }
     }
-    catch { }
     return options.outputPath;
 }
+exports.repackAppAndroidAsync = repackAppAndroidAsync;

package/build/android/resources.d.ts

@@ -1,5 +1,5 @@
 import { type ExpoConfig } from '@expo/config';
-import type { NormalizedOptions } from '../types.js';
+import type { NormalizedOptions } from '../types';
 /**
  * Update resources inside the **resources.pb** file.
  */

package/build/android/resources.js

@@ -1,36 +1,43 @@
-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';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAndroidManifestAsync = exports.updateResourcesAsync = void 0;
+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 protobufjs_1 = __importDefault(require("protobufjs"));
+const utils_1 = require("../utils");
 /**
  * Update resources inside the **resources.pb** file.
  */
-export async function updateResourcesAsync(config, resourcesPbFilePath) {
-    const root = await protobuf.load(path.join(import.meta.dirname, '../../assets', 'Resources.proto'));
+async function updateResourcesAsync(config, resourcesPbFilePath) {
+    const root = await protobufjs_1.default.load(node_path_1.default.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');
+    (0, node_assert_1.default)(resourceTable.package.length === 1, 'Expected only one package');
+    (0, node_assert_1.default)(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"');
+    (0, node_assert_1.default)(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);
 }
+exports.updateResourcesAsync = updateResourcesAsync;
 /**
  * Update the proto-based AndroidManiest.xml.
  */
-export async function updateAndroidManifestAsync(config, androidManiestFilePath, options, updatesRuntimeVersion) {
-    const root = await protobuf.load(path.join(import.meta.dirname, '../../assets', 'Resources.proto'));
+async function updateAndroidManifestAsync(config, androidManiestFilePath, options, updatesRuntimeVersion) {
+    const root = await protobufjs_1.default.load(node_path_1.default.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)));
+    replaceXmlAttributeValue(rootNode, (value) => value.replace(/dev\.expo\.templatedefault\.appid/g, (0, utils_1.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' &&
@@ -39,19 +46,20 @@ export async function updateAndroidManifestAsync(config, androidManiestFilePath,
     for (const node of intentFilterViewActionNodes) {
         replaceXmlAttributeValue(node, (value) => value
             // scheme in app.json
-            .replace(/^myapp$/g, requireNotNull(firstScheme))
+            .replace(/^myapp$/g, (0, utils_1.requireNotNull)(firstScheme))
             // android.package in app.json
-            .replace(/^dev\.expo\.templatedefault$/g, requireNotNull(config.android?.package))
+            .replace(/^dev\.expo\.templatedefault$/g, (0, utils_1.requireNotNull)(config.android?.package))
             // default scheme generated from slug in app.json
-            .replace(/^exp\+expo-template-default$/g, `exp+${requireNotNull(config.slug)}`));
+            .replace(/^exp\+expo-template-default$/g, `exp+${(0, utils_1.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');
+    (0, node_assert_1.default)(mainApplicationNode != null, 'Expected application node to be present');
     mutateExpoUpdatesConfigAsync(mainApplicationNode, config, updatesRuntimeVersion);
     await encodeProtoFile(xmlNodeType, androidManiestFilePath, rootNode);
 }
+exports.updateAndroidManifestAsync = updateAndroidManifestAsync;
 //#region Internals
 /**
  * Update the `expo-updates` configuration in the Android project.
@@ -59,11 +67,11 @@ export async function updateAndroidManifestAsync(config, androidManiestFilePath,
 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, node_assert_1.default)(updateEnabledNodeIndex != null && updateEnabledNodeIndex >= 0, `Expected 'expo.modules.updates.ENABLED' node to be present`);
+    const updateEnabledNode = (0, utils_1.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');
+    (0, node_assert_1.default)(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' &&
@@ -72,19 +80,19 @@ function mutateExpoUpdatesConfigAsync(mainApplicationNode, config, runtimeVersio
         mainApplicationNode.element?.child.splice(updateEnabledNodeIndex + 1, 0, createUpdateStringNode(updateEnabledNode, 'expo.modules.updates.EXPO_RUNTIME_VERSION', runtimeVersion));
     }
     else {
-        assert(updateRuntimeVersionNode.element != null);
+        (0, node_assert_1.default)(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);
+    (0, node_assert_1.default)(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);
+        (0, node_assert_1.default)(updateUrlNode.element != null);
         updateUrlNode.element.attribute[1].value = updateUrl;
     }
 }
@@ -92,7 +100,7 @@ function mutateExpoUpdatesConfigAsync(mainApplicationNode, config, runtimeVersio
  * 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 buffer = await promises_1.default.readFile(filePath);
     const message = await protoType.decode(buffer);
     const json = protoType.toObject(message, {
         longs: String,
@@ -108,7 +116,7 @@ async function decodeProtoFile(protoType, filePath) {
 async function encodeProtoFile(protoType, filePath, json) {
     const updatedMessage = protoType.fromObject(json);
     const updatedBuffer = protoType.encode(updatedMessage).finish();
-    await fs.writeFile(filePath, updatedBuffer);
+    await promises_1.default.writeFile(filePath, updatedBuffer);
 }
 /**
  * Recursively find XML nodes that satisfy the given `predicate`.
@@ -145,7 +153,7 @@ function createUpdateStringNode(updateEnabledNode, name, value) {
     return {
         ...updateEnabledNode,
         element: {
-            ...requireNotNull(updateEnabledNode.element),
+            ...(0, utils_1.requireNotNull)(updateEnabledNode.element),
             attribute: [
                 {
                     namespaceUri: 'http://schemas.android.com/apk/res/android',

package/build/cli.js

@@ -1,9 +1,13 @@
-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')
+"use strict";
+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 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')
@@ -22,10 +26,11 @@ const program = new Command('repack-app')
     .argument('<project-root>', 'Path to the project root')
     .parse(process.argv);
 async function runAsync() {
+    const logger = (0, logger_1.createLogger)({ name: 'repack-app' });
     const platform = program.opts().platform;
     const projectRoot = program.args[0];
     if (platform === 'android') {
-        const outputPath = await repackAppAndroidAsync({
+        const outputPath = await (0, index_1.repackAppAndroidAsync)({
             platform: program.opts().platform,
             projectRoot,
             verbose: !!program.opts().verbose,
@@ -39,8 +44,9 @@ async function runAsync() {
                 keyPassword: program.opts().ksKeyPass,
             },
             androidBuildToolsDir: program.opts().androidBuildToolsDir,
+            logger,
         });
-        logger.log(pico.green(`Updated APK created at ${outputPath}`));
+        logger.info(picocolors_1.default.green(`Updated APK created at ${outputPath}`));
     }
     else if (platform === 'ios') {
         const options = {
@@ -54,14 +60,10 @@ async function runAsync() {
                 signingIdentity: program.opts().signingIdentity,
                 provisioningProfile: program.opts().provisioningProfile,
             },
+            logger,
         };
-        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);
-        }
+        const outputPath = await (0, index_1.repackAppIosAsync)(options);
+        logger.info(picocolors_1.default.green(`Updated IPA created at ${outputPath}`));
     }
     else {
         throw new Error(`Unsupported platform: ${platform}`);

package/build/expo.d.ts

@@ -1,5 +1,5 @@
 import { type ExpoConfig } from '@expo/config';
-import type { NormalizedOptions } from './types.js';
+import type { NormalizedOptions } from './types';
 /**
  * Generate the app.config file for the Android app.
  */

package/build/expo.js

@@ -1,26 +1,34 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import resolveFrom from 'resolve-from';
-import { spawnAsync } from './cjs-wrapper.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimeVersionAsync = exports.generateAppConfigAsync = void 0;
+const steps_1 = require("@expo/steps");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const resolve_from_1 = __importDefault(require("resolve-from"));
 /**
  * Generate the app.config file for the Android app.
  */
-export async function generateAppConfigAsync(options, config) {
+async function generateAppConfigAsync(options, config) {
     const { workingDirectory } = options;
-    const appConfigPath = path.join(workingDirectory, 'app.config');
-    await fs.writeFile(appConfigPath, JSON.stringify(config));
+    const appConfigPath = node_path_1.default.join(workingDirectory, 'app.config');
+    await promises_1.default.writeFile(appConfigPath, JSON.stringify(config));
     return appConfigPath;
 }
+exports.generateAppConfigAsync = generateAppConfigAsync;
 /**
  * Resolve the `runtimeVersion` for expo-updates.
  */
-export async function resolveRuntimeVersionAsync(options, config) {
+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'], {
+    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'], {
         cwd: projectRoot,
     });
     const runtimeVersion = JSON.parse(proc.stdout).runtimeVersion;
     return runtimeVersion ?? config.version ?? '1.0.0';
 }
+exports.resolveRuntimeVersionAsync = resolveRuntimeVersionAsync;

package/build/index.d.ts

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

package/build/index.js

@@ -1,2 +1,7 @@
-export { repackAppAndroidAsync } from './android/index.js';
-export { repackAppIosAsync } from './ios/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repackAppIosAsync = exports.repackAppAndroidAsync = void 0;
+var android_1 = require("./android");
+Object.defineProperty(exports, "repackAppAndroidAsync", { enumerable: true, get: function () { return android_1.repackAppAndroidAsync; } });
+var ios_1 = require("./ios");
+Object.defineProperty(exports, "repackAppIosAsync", { enumerable: true, get: function () { return ios_1.repackAppIosAsync; } });

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

@@ -1,5 +1,5 @@
 import { type ExpoConfig } from '@expo/config';
-import type { NormalizedOptions } from '../types.js';
+import type { NormalizedOptions } from '../types';
 /**
  * Unzip the IPA file.
  */

package/build/ios/build-tools.js

@@ -1,43 +1,49 @@
-import assert from 'node:assert';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { spawnAsync } from '../cjs-wrapper.js';
-import { directoryExistsAsync } from '../utils.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIpaAsync = exports.updateFilesAsync = exports.unzipIpaAsync = void 0;
+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"));
+const utils_1 = require("../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));
+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));
     return appWorkingDirectory;
 }
+exports.unzipIpaAsync = unzipIpaAsync;
 /**
  * Update some binary files.
  */
-export async function updateFilesAsync(config, appWorkingDirectory) {
-    const parentDir = path.dirname(appWorkingDirectory);
-    const newAppWorkingDirectory = path.join(parentDir, `${config.name}.app`);
+async function updateFilesAsync(config, appWorkingDirectory) {
+    const parentDir = node_path_1.default.dirname(appWorkingDirectory);
+    const newAppWorkingDirectory = node_path_1.default.join(parentDir, `${config.name}.app`);
     // [0] Update the .app directory
-    await fs.rename(path.join(parentDir, 'HelloWorld.app'), newAppWorkingDirectory);
+    await promises_1.default.rename(node_path_1.default.join(parentDir, 'HelloWorld.app'), newAppWorkingDirectory);
     // [1] Rename the executable
-    await fs.rename(path.join(newAppWorkingDirectory, 'HelloWorld'), path.join(newAppWorkingDirectory, config.name));
+    await promises_1.default.rename(node_path_1.default.join(newAppWorkingDirectory, 'HelloWorld'), node_path_1.default.join(newAppWorkingDirectory, config.name));
     return newAppWorkingDirectory;
 }
+exports.updateFilesAsync = updateFilesAsync;
 /**
  * From the given working .app directory, create a new .ipa file.
  */
-export async function createIpaAsync(options, appWorkingDirectory) {
+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',
-    });
+    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.join(workingDirectory, 'repacked.ipa');
+    await (0, steps_1.spawnAsync)('zip', ['-r', outputIpaPath, 'Payload'], options.verbose
+        ? { logger: options.logger, stdio: 'pipe', cwd: workingDirectory }
+        : { cwd: workingDirectory });
     return outputIpaPath;
 }
+exports.createIpaAsync = createIpaAsync;

package/build/ios/index.d.ts

@@ -1,4 +1,4 @@
-import type { IosSigningOptions, Options } from '../types.js';
+import type { IosSigningOptions, Options } from '../types';
 /**
  * Repack an iOS app.
  */

package/build/ios/index.js

@@ -1,54 +1,67 @@
-import { getConfig } from '@expo/config';
-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 { spawnAsync } from '../cjs-wrapper.js';
-import { generateAppConfigAsync, resolveRuntimeVersionAsync } from '../expo.js';
-import logger from '../log.js';
-import { normalizeOptionAsync } from '../utils.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resignIpaAsync = exports.repackAppIosAsync = void 0;
+const config_1 = require("@expo/config");
+const steps_1 = require("@expo/steps");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const build_tools_1 = require("./build-tools");
+const resources_1 = require("./resources");
+const expo_1 = require("../expo");
+const utils_1 = require("../utils");
 /**
  * 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, {
+async function repackAppIosAsync(_options) {
+    const options = await (0, utils_1.normalizeOptionAsync)(_options);
+    const { workingDirectory, logger } = options;
+    await promises_1.default.mkdir(workingDirectory, { recursive: true });
+    const { exp } = (0, config_1.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 });
+    const updatesRuntimeVersion = await (0, expo_1.resolveRuntimeVersionAsync)(options, exp);
+    logger.info(picocolors_1.default.dim(`Resolved runtime version: ${updatesRuntimeVersion}`));
+    logger.info(`Unzipping IPA`);
+    let appWorkingDirectory = await (0, build_tools_1.unzipIpaAsync)(options);
+    appWorkingDirectory = await (0, build_tools_1.updateFilesAsync)(exp, appWorkingDirectory);
+    logger.info(`Finished unzipping IPA ✅`);
+    logger.info(`Updating Info.plist`);
+    await (0, resources_1.updateInfoPlistAsync)(exp, node_path_1.default.join(appWorkingDirectory, 'Info.plist'), options);
+    logger.info(`Finished updating Info.plist ✅`);
+    logger.info(`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`);
+    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 ✅`);
+    if (options.iosSigningOptions) {
+        logger.info(`Resigning the IPA at ${outputIpa}`);
+        await resignIpaAsync(outputIpa, options.iosSigningOptions, options);
+        logger.info(`Finished resigning the IPA ✅`);
+    }
+    await promises_1.default.rename(outputIpa, options.outputPath);
+    if (!options.skipWorkingDirCleanup) {
+        try {
+            await promises_1.default.rmdir(workingDirectory, { recursive: true });
+        }
+        catch { }
     }
-    catch { }
     return options.outputPath;
 }
+exports.repackAppIosAsync = repackAppIosAsync;
 /**
  * Resign an IPA by fastlane.
  */
-export async function resignIpaAsync(ipaPath, signingOptions, options) {
+async function resignIpaAsync(ipaPath, signingOptions, options) {
     const args = [
         'run',
         'resign',
@@ -59,7 +72,6 @@ export async function resignIpaAsync(ipaPath, signingOptions, options) {
     if (signingOptions.keychainPath) {
         args.push(`keychain_path:${signingOptions.keychainPath}`);
     }
-    await spawnAsync('fastlane', args, {
-        stdio: options.verbose ? 'inherit' : 'ignore',
-    });
+    await (0, steps_1.spawnAsync)('fastlane', args, { logger: options.logger, stdio: 'pipe' });
 }
+exports.resignIpaAsync = resignIpaAsync;

package/build/ios/resources.d.ts

@@ -1,5 +1,5 @@
 import { type ExpoConfig } from '@expo/config';
-import type { NormalizedOptions } from '../types.js';
+import type { NormalizedOptions } from '../types';
 /**
  * Update the Info.plist file.
  */

package/build/ios/resources.js

@@ -1,13 +1,20 @@
-import assert from 'node:assert';
-import fs from 'node:fs/promises';
-import { plist, spawnAsync } from '../cjs-wrapper.js';
-import { requireNotNull } from '../utils.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateExpoPlistAsync = exports.updateInfoPlistAsync = void 0;
+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 utils_1 = require("../utils");
 /**
  * Update the Info.plist file.
  */
-export async function updateInfoPlistAsync(config, infoPlistPath, options) {
+async function updateInfoPlistAsync(config, infoPlistPath, options) {
     const bundleIdentifier = config.ios?.bundleIdentifier;
-    assert(bundleIdentifier, 'The `bundleIdentifier` must be specified in the `ios` config.');
+    (0, node_assert_1.default)(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();
@@ -16,11 +23,11 @@ export async function updateInfoPlistAsync(config, infoPlistPath, options) {
                 const schemes = urlType.CFBundleURLSchemes.map((scheme) => {
                     return (scheme
                         // scheme in app.json
-                        .replace(/^myapp$/g, requireNotNull(firstScheme))
+                        .replace(/^myapp$/g, (0, utils_1.requireNotNull)(firstScheme))
                         // ios.bundleIdentifier in app.json
-                        .replace(/^dev.expo.templatedefault$/g, requireNotNull(bundleIdentifier))
+                        .replace(/^dev.expo.templatedefault$/g, (0, utils_1.requireNotNull)(bundleIdentifier))
                         // default scheme generated from slug in app.json
-                        .replace(/^exp\+expo-template-default$/g, `exp+${requireNotNull(config.slug)}`));
+                        .replace(/^exp\+expo-template-default$/g, `exp+${(0, utils_1.requireNotNull)(config.slug)}`));
                 });
                 urlType.CFBundleURLSchemes = schemes;
             }
@@ -36,13 +43,14 @@ export async function updateInfoPlistAsync(config, infoPlistPath, options) {
         };
     });
 }
+exports.updateInfoPlistAsync = updateInfoPlistAsync;
 /**
  * Update the Expo.plist file.
  */
-export async function updateExpoPlistAsync(config, expoPlistPath, runtimeVersion, options) {
+async function updateExpoPlistAsync(config, expoPlistPath, runtimeVersion, options) {
     await updateBinaryPlistAsync(expoPlistPath, options, (data) => {
         const updateUrl = config.updates?.url;
-        assert(updateUrl);
+        (0, node_assert_1.default)(updateUrl);
         return {
             ...data,
             EXUpdatesEnabled: true,
@@ -51,18 +59,15 @@ export async function updateExpoPlistAsync(config, expoPlistPath, runtimeVersion
         };
     });
 }
+exports.updateExpoPlistAsync = updateExpoPlistAsync;
 //#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);
+    await (0, steps_1.spawnAsync)('plutil', ['-convert', 'xml1', plistPath], options.verbose ? { logger: options.logger, stdio: 'pipe' } : undefined);
+    const contents = await promises_1.default.readFile(plistPath, 'utf8');
+    const data = await plist_1.default.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',
-    });
+    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);
 }
 //#endregion

package/build/types.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="bunyan" />
+import type { bunyan } from '@expo/logger';
 export interface Options {
     /**
      * The platform to repack the app for.
@@ -11,6 +13,10 @@ 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.
      */
@@ -37,6 +43,10 @@ export interface Options {
      * The options for signing the ios app.
      */
     iosSigningOptions?: IosSigningOptions;
+    /**
+     * Skip the working directory cleanup.
+     */
+    skipWorkingDirCleanup?: boolean;
 }
 export interface NormalizedOptions extends Options {
     workingDirectory: NonNullable<Options['workingDirectory']>;

package/build/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils.js

@@ -1,29 +1,36 @@
-import assert from 'node:assert';
-import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-const require = createRequire(import.meta.url);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptionAsync = exports.requireNotNull = exports.directoryExistsAsync = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 /**
  * Check if a directory exists.
  */
-export async function directoryExistsAsync(file) {
-    return (await fs.stat(file).catch(() => null))?.isDirectory() ?? false;
+async function directoryExistsAsync(file) {
+    return (await promises_1.default.stat(file).catch(() => null))?.isDirectory() ?? false;
 }
+exports.directoryExistsAsync = directoryExistsAsync;
 /**
  * Return the non-null value.
  */
-export function requireNotNull(value) {
-    assert(value != null, 'Expected value to be non-null');
+function requireNotNull(value) {
+    (0, node_assert_1.default)(value != null, 'Expected value to be non-null');
     return value;
 }
+exports.requireNotNull = requireNotNull;
 /**
  * Normalize the options.
  */
-export async function normalizeOptionAsync(options) {
+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}`),
+        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}`),
     };
 }
+exports.normalizeOptionAsync = normalizeOptionAsync;

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@expo/repack-app",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Repacking tool for Expo apps",
   "main": "build/index.js",
-  "module": "build/index.js",
   "types": "build/index.d.ts",
-  "type": "module",
+  "type": "commonjs",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",
@@ -27,8 +26,9 @@
   "license": "BUSL-1.1",
   "dependencies": {
     "@expo/config": "^8.5.6",
-    "@expo/turtle-spawn": "^1.0.57",
-    "commander": "^12.0.0",
+    "@expo/logger": "^1.0.57",
+    "@expo/steps": "^1.0.108",
+    "commander": "^11.0.0",
     "glob": "^10.3.12",
     "picocolors": "^1.0.0",
     "protobufjs": "^7.2.6",
@@ -40,5 +40,8 @@
     "eslint": "^8.57.0",
     "expo-module-scripts": "^3.4.2",
     "typescript": "^5.4.5"
+  },
+  "volta": {
+    "node": "22.1.0"
   }
 }

package/build/cjs-wrapper.d.ts

@@ -1,5 +0,0 @@
-export declare const spawnAsync: typeof import("@expo/turtle-spawn").default;
-export declare const plist: {
-    parse: typeof import("@expo/plist/build/parse").parse;
-    build: typeof import("@expo/plist/build/build").build;
-};

package/build/cjs-wrapper.js

@@ -1,5 +0,0 @@
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-export const spawnAsync = require('@expo/turtle-spawn')
-    .default;
-export const plist = require('@expo/plist').default;

package/build/log.d.ts

@@ -1,13 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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,
-};