@revopush/code-push-cli 0.0.8-rc.0 → 0.0.8-rc.1

package/bin/script/command-parser.js

@@ -743,6 +743,207 @@ yargs
         return checkValidReleaseOptions(argv);
     });
     addCommonConfiguration(yargs);
+})
+    .command("release-expo", "Release an Expo / React Native update to an app deployment", (yargs) => {
+    isValidCommand = true;
+    yargs
+        .usage(USAGE_PREFIX + " release-expo <appName> <platform> [options]")
+        .demand(/*count*/ 2, /*max*/ 2) // Require exactly two non-option arguments
+        .example("release-expo MyApp ios", 'Releases the Expo-managed iOS project in the current working directory to the "MyApp" app\'s "Staging" deployment')
+        .example("release-expo MyApp android -d Production", 'Releases the Expo-managed Android project in the current working directory to the "MyApp" app\'s "Production" deployment')
+        .option("bundleName", {
+        alias: "b",
+        default: null,
+        demand: false,
+        description: 'Name of the generated JS bundle file. If unspecified, the standard bundle name will be used, depending on the specified platform: "main.jsbundle" (iOS), "index.android.bundle" (Android) or "index.windows.bundle" (Windows)',
+        type: "string",
+    })
+        .option("deploymentName", {
+        alias: "d",
+        default: "Staging",
+        demand: false,
+        description: "Deployment to release the update to",
+        type: "string",
+    })
+        .option("description", {
+        alias: "des",
+        default: null,
+        demand: false,
+        description: "Description of the changes made to the app with this release",
+        type: "string",
+    })
+        .option("development", {
+        alias: "dev",
+        default: false,
+        demand: false,
+        description: "Specifies whether to generate a dev or release build",
+        type: "boolean",
+    })
+        .option("disabled", {
+        alias: "x",
+        default: false,
+        demand: false,
+        description: "Specifies whether this release should be immediately downloadable",
+        type: "boolean",
+    })
+        .option("entryFile", {
+        alias: "e",
+        default: null,
+        demand: false,
+        description: 'Path to the app\'s entry Javascript file. If omitted, "index.<platform>.js" and then "index.js" will be used (if they exist)',
+        type: "string",
+    })
+        .option("gradleFile", {
+        alias: "g",
+        default: null,
+        demand: false,
+        description: "Path to the gradle file which specifies the binary version you want to target this release at (android only).",
+    })
+        .option("initial", {
+        alias: "i",
+        default: false,
+        demand: false,
+        description: "Specifies whether release is initial (base) for given targetBinaryVersion.",
+        type: "boolean",
+    })
+        .option("mandatory", {
+        alias: "m",
+        default: false,
+        demand: false,
+        description: "Specifies whether this release should be considered mandatory",
+        type: "boolean",
+    })
+        .option("noDuplicateReleaseError", {
+        default: false,
+        demand: false,
+        description: "When this flag is set, releasing a package that is identical to the latest release will produce a warning instead of an error",
+        type: "boolean",
+    })
+        .option("plistFile", {
+        alias: "p",
+        default: null,
+        demand: false,
+        description: "Path to the plist file which specifies the binary version you want to target this release at (iOS only).",
+    })
+        .option("plistFilePrefix", {
+        alias: "pre",
+        default: null,
+        demand: false,
+        description: "Prefix to append to the file name when attempting to find your app's Info.plist file (iOS only).",
+    })
+        .option("rollout", {
+        alias: "r",
+        default: "100%",
+        demand: false,
+        description: "Percentage of users this release should be immediately available to",
+        type: "string",
+    })
+        .option("sourcemapOutput", {
+        alias: "s",
+        default: null,
+        demand: false,
+        description: "Path to where the sourcemap for the resulting bundle should be written. If omitted, a sourcemap will not be generated.",
+        type: "string",
+    })
+        .option("targetBinaryVersion", {
+        alias: "t",
+        default: null,
+        demand: false,
+        description: 'Semver expression that specifies the binary app version(s) this release is targeting (e.g. 1.1.0, ~1.2.3). If omitted, the release will target the exact version specified in the "Info.plist" (iOS), "build.gradle" (Android) or "Package.appxmanifest" (Windows) files.',
+        type: "string",
+    })
+        .option("outputDir", {
+        alias: "o",
+        default: null,
+        demand: false,
+        description: "Path to where the bundle and sourcemap should be written. If omitted, a bundle and sourcemap will not be written.",
+        type: "string",
+    })
+        .option("useHermes", {
+        alias: "h",
+        default: false,
+        demand: false,
+        description: "Enable hermes and bypass automatic checks",
+        type: "boolean",
+    })
+        .option("podFile", {
+        alias: "pod",
+        default: null,
+        demand: false,
+        description: "Path to the cocopods config file (iOS only).",
+        type: "string",
+    })
+        .option("extraHermesFlags", {
+        alias: "hf",
+        default: [],
+        demand: false,
+        description: "Flags that get passed to Hermes, JavaScript to bytecode compiler. Can be specified multiple times.",
+        type: "array",
+    })
+        .option("privateKeyPath", {
+        alias: "k",
+        default: null,
+        demand: false,
+        description: "Path to private key used for code signing.",
+        type: "string",
+    })
+        .option("xcodeProjectFile", {
+        alias: "xp",
+        default: null,
+        demand: false,
+        description: "Path to the Xcode project or project.pbxproj file",
+        type: "string",
+    })
+        .option("xcodeTargetName", {
+        alias: "xt",
+        default: undefined,
+        demand: false,
+        description: "Name of target (PBXNativeTarget) which specifies the binary version you want to target this release at (iOS only)",
+        type: "string",
+    })
+        .option("buildConfigurationName", {
+        alias: "c",
+        default: undefined,
+        demand: false,
+        description: "Name of build configuration which specifies the binary version you want to target this release at. For example, 'Debug' or 'Release' (iOS only)",
+        type: "string",
+    })
+        .option("extraBundlerOption", {
+        alias: "eo",
+        default: [],
+        demand: false,
+        description: "Option that gets passed to react-native bundler. Can be specified multiple times.",
+        type: "array",
+    })
+        .check((argv) => {
+        return checkValidReleaseOptions(argv);
+    });
+    addCommonConfiguration(yargs);
+})
+    .command("release-native", "Release a binary update to an app deployment", (yargs) => {
+    yargs
+        .usage(USAGE_PREFIX + " release-native <appName> <platform> <targetBinary> [options]")
+        .demand(/*count*/ 3, /*max*/ 3) // Require exactly three non-option arguments
+        .example("release-native MyApp ios ./app.ipa", 'Releases the React Native iOS project from "./app.ipa" to the "MyApp" app\'s "Staging" deployment')
+        .example("release-native MyApp android ./app.apk -d Production", 'Releases the React Native Android project from "./app.apk" to the "MyApp" app\'s "Production" deployment')
+        .option("deploymentName", {
+        alias: "d",
+        default: "Staging",
+        demand: false,
+        description: "Deployment to release the update to",
+        type: "string",
+    })
+        .option("targetBinaryVersion", {
+        alias: "t",
+        default: null,
+        demand: false,
+        description: "Semver expression that specifies the binary app version(s) this release is targeting (e.g. 1.1.0, ~1.2.3).",
+        type: "string",
+    })
+        .check((argv, aliases) => {
+        return checkValidReleaseOptions(argv);
+    });
+    addCommonConfiguration(yargs);
 })
     .command("rollback", "Rollback the latest release for an app deployment", (yargs) => {
     yargs
@@ -1070,6 +1271,54 @@ function createCommand() {
                     releaseReactCommand.extraBundlerOptions = argv["extraBundlerOption"];
                 }
                 break;
+            case "release-expo":
+                if (arg1 && arg2) {
+                    cmd = { type: cli.CommandType.releaseExpo };
+                    const releaseExpoCommand = cmd;
+                    releaseExpoCommand.appName = arg1;
+                    releaseExpoCommand.platform = arg2;
+                    releaseExpoCommand.appStoreVersion = argv["targetBinaryVersion"];
+                    releaseExpoCommand.bundleName = argv["bundleName"];
+                    releaseExpoCommand.deploymentName = argv["deploymentName"];
+                    releaseExpoCommand.disabled = argv["disabled"];
+                    releaseExpoCommand.description = argv["description"] ? backslash(argv["description"]) : "";
+                    releaseExpoCommand.development = argv["development"];
+                    releaseExpoCommand.entryFile = argv["entryFile"];
+                    releaseExpoCommand.gradleFile = argv["gradleFile"];
+                    releaseExpoCommand.mandatory = argv["mandatory"];
+                    releaseExpoCommand.initial = argv["initial"];
+                    releaseExpoCommand.noDuplicateReleaseError = argv["noDuplicateReleaseError"];
+                    releaseExpoCommand.plistFile = argv["plistFile"];
+                    releaseExpoCommand.plistFilePrefix = argv["plistFilePrefix"];
+                    releaseExpoCommand.rollout = getRolloutValue(argv["rollout"]);
+                    releaseExpoCommand.sourcemapOutput = argv["sourcemapOutput"];
+                    releaseExpoCommand.outputDir = argv["outputDir"];
+                    releaseExpoCommand.useHermes = argv["useHermes"];
+                    releaseExpoCommand.extraHermesFlags = argv["extraHermesFlags"];
+                    releaseExpoCommand.podFile = argv["podFile"];
+                    releaseExpoCommand.privateKeyPath = argv["privateKeyPath"];
+                    releaseExpoCommand.xcodeProjectFile = argv["xcodeProjectFile"];
+                    releaseExpoCommand.xcodeTargetName = argv["xcodeTargetName"];
+                    releaseExpoCommand.buildConfigurationName = argv["buildConfigurationName"];
+                    releaseExpoCommand.extraBundlerOptions = argv["extraBundlerOption"];
+                }
+                break;
+            case "release-native":
+                if (arg1 && arg2 && arg3) {
+                    cmd = { type: cli.CommandType.releaseNative };
+                    const releaseBinaryCommand = cmd;
+                    releaseBinaryCommand.appName = arg1;
+                    releaseBinaryCommand.platform = arg2;
+                    releaseBinaryCommand.targetBinary = arg3;
+                    releaseBinaryCommand.deploymentName = argv["deploymentName"];
+                    releaseBinaryCommand.appStoreVersion = argv["targetBinaryVersion"];
+                    releaseBinaryCommand.initial = true;
+                    releaseBinaryCommand.disabled = true;
+                    releaseBinaryCommand.mandatory = false;
+                    // TODO add support for releaseBinaryCommand.bundleName
+                    // TODO add support for releaseBinaryCommand.outputDir
+                }
+                break;
             case "rollback":
                 if (arg1 && arg2) {
                     cmd = { type: cli.CommandType.rollback };

package/bin/script/expo-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpoCliPath = void 0;
+const childProcess = require("child_process");
+function getExpoCliPath() {
+    const result = childProcess.spawnSync("node", ["--print", "require.resolve('@expo/cli')"]);
+    const cliPath = result.stdout.toString().trim();
+    if (result.status === 0 && cliPath) {
+        return cliPath;
+    }
+    throw new Error('Unable to resolve "@expo/cli". Please make sure it is installed in your project (e.g. "npm install --save-dev @expo/cli").');
+}
+exports.getExpoCliPath = getExpoCliPath;

package/bin/script/management-sdk.js

@@ -268,6 +268,51 @@ class AccountManager {
             });
         });
     }
+    releaseNative(appName, deploymentName, filePath, updateMetadata, uploadProgressCallback) {
+        return Promise((resolve, reject, notify) => {
+            const request = superagent.post(this._serverUrl + urlEncode([`/apps/${appName}/deployments/${deploymentName}/nativerelease`]));
+            this.attachCredentials(request);
+            const file = fs.createReadStream(filePath);
+            request
+                .attach("package", file)
+                .field("packageInfo", JSON.stringify(updateMetadata))
+                .on("progress", (event) => {
+                if (uploadProgressCallback && event && event.total > 0) {
+                    const currentProgress = (event.loaded / event.total) * 100;
+                    uploadProgressCallback(currentProgress);
+                }
+            })
+                .end((err, res) => {
+                fs.unlinkSync(filePath);
+                if (err) {
+                    reject(this.getCodePushError(err, res));
+                    return;
+                }
+                if (res.ok) {
+                    resolve(null);
+                }
+                else {
+                    let body;
+                    try {
+                        body = JSON.parse(res.text);
+                    }
+                    catch (err) { }
+                    if (body) {
+                        reject({
+                            message: body.message,
+                            statusCode: res && res.status,
+                        });
+                    }
+                    else {
+                        reject({
+                            message: res.text,
+                            statusCode: res && res.status,
+                        });
+                    }
+                }
+            });
+        });
+    }
     patchRelease(appName, deploymentName, label, updateMetadata) {
         updateMetadata.label = label;
         const requestBody = JSON.stringify({ packageInfo: updateMetadata });

package/bin/script/react-native-utils.js

@@ -51,7 +51,7 @@ async function takeHermesBaseBytecode(command, baseReleaseTmpFolder, outputFolde
         return null;
     }
     const baseReleaseArchive = await (0, file_utils_1.downloadBlob)(bundleBlobUrl, baseReleaseTmpFolder);
-    await (0, file_utils_1.extract)(baseReleaseArchive, baseReleaseTmpFolder);
+    await (0, file_utils_1.extractIPA)(baseReleaseArchive, baseReleaseTmpFolder);
     const baseReleaseBundle = path.join(baseReleaseTmpFolder, path.basename(outputFolder), bundleName);
     if (!fs.existsSync(baseReleaseBundle)) {
         (0, command_executor_1.log)(chalk.cyan("\nNo base release available...\n"));
@@ -72,6 +72,8 @@ async function runHermesEmitBinaryCommand(command, bundleName, outputFolder, sou
         "-out",
         path.join(outputFolder, bundleName + ".hbc"),
         path.join(outputFolder, bundleName),
+        "-w",
+        "-max-diagnostic-width=80",
         ...extraHermesFlags,
     ]);
     if (sourcemapOutputFolder) {

package/bin/script/types/cli.js

@@ -37,4 +37,6 @@ var CommandType;
     CommandType[CommandType["sessionList"] = 29] = "sessionList";
     CommandType[CommandType["sessionRemove"] = 30] = "sessionRemove";
     CommandType[CommandType["whoami"] = 31] = "whoami";
+    CommandType[CommandType["releaseExpo"] = 32] = "releaseExpo";
+    CommandType[CommandType["releaseNative"] = 33] = "releaseNative";
 })(CommandType || (exports.CommandType = CommandType = {}));

package/bin/script/utils/file-utils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = exports.downloadBlob = exports.normalizePath = exports.fileDoesNotExistOrIsDirectory = exports.copyFileToTmpDir = exports.fileExists = exports.isDirectory = exports.isBinaryOrZip = void 0;
+exports.extractAPK = exports.extractIPA = exports.downloadBlob = exports.normalizePath = exports.fileDoesNotExistOrIsDirectory = exports.copyFileToTmpDir = exports.fileExists = exports.isDirectory = exports.isBinaryOrZip = void 0;
 const fs = require("fs");
 const path = require("path");
 const rimraf = require("rimraf");
 const temp = require("temp");
 const unzipper = require("unzipper");
+const AdmZip = require("adm-zip");
 const superagent = require("superagent");
 function isBinaryOrZip(path) {
     return path.search(/\.zip$/i) !== -1 || path.search(/\.apk$/i) !== -1 || path.search(/\.ipa$/i) !== -1;
@@ -66,10 +67,15 @@ async function downloadBlob(url, folder, filename = "blob.zip") {
     });
 }
 exports.downloadBlob = downloadBlob;
-async function extract(zipPath, extractTo) {
+async function extractIPA(zipPath, extractTo) {
     const extractStream = unzipper.Extract({ path: extractTo });
     await new Promise((resolve, reject) => {
         fs.createReadStream(zipPath).pipe(extractStream).on("close", resolve).on("error", reject);
     });
 }
-exports.extract = extract;
+exports.extractIPA = extractIPA;
+async function extractAPK(zipPath, extractTo) {
+    const zip = new AdmZip(zipPath);
+    zip.extractAllTo(extractTo, true);
+}
+exports.extractAPK = extractAPK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revopush/code-push-cli",
-  "version": "0.0.8-rc.0",
+  "version": "0.0.8-rc.1",
   "description": "Management CLI for the CodePush service",
   "main": "./script/cli.js",
   "scripts": {
@@ -23,7 +23,10 @@
     "Revopush"
   ],
   "dependencies": {
+    "@devicefarmer/adbkit-apkreader": "^3.2.4",
+    "adm-zip": "^0.5.16",
     "backslash": "^0.2.0",
+    "bplist-parser": "^0.3.2",
     "chalk": "^4.1.2",
     "cli-table": "^0.3.11",
     "dotenv": "^17.2.1",
@@ -33,7 +36,7 @@
     "moment": "^2.29.4",
     "opener": "^1.5.2",
     "parse-duration": "1.1.0",
-    "plist": "^3.0.6",
+    "plist": "^3.1.0",
     "progress": "^2.0.3",
     "prompt": "^1.3.0",
     "properties": "^1.2.1",

package/script/binary-utils.ts

@@ -0,0 +1,209 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as chalk from "chalk";
+import { log } from "./command-executor";
+import { hashFile } from "./hash-utils";
+import * as os from "os";
+import * as Q from "q";
+import * as yazl from "yazl";
+import { readFile } from "node:fs/promises";
+import plist from "plist"
+import * as bplist from "bplist-parser";
+
+export async function extractMetadataFromAndroid(extractFolder, outputFolder) {
+  const assetsFolder = path.join(extractFolder, "assets");
+  if (!fs.existsSync(assetsFolder)) {
+    throw new Error("Invalid APK structure: assets folder not found.");
+  }
+
+  const codepushMetadata = path.join(assetsFolder, "CodePushMetadata");
+
+  let fileHashes: { [key: string]: string } = {};
+  if (fs.existsSync(codepushMetadata)) {
+    fileHashes = await takeHashesFromMetadata(codepushMetadata);
+  } else {
+    log(chalk.yellow(`\nWarning: CodepushMetadata file not found in APK. Check used version of SDK\n`));
+  }
+
+  // Get index.android.bundle from root of app folder
+  const mainJsBundlePath = path.join(assetsFolder, "index.android.bundle");
+  if (fs.existsSync(mainJsBundlePath)) {
+    // Copy bundle to output folder
+    const outputCodePushFolder = path.join(outputFolder, "CodePush");
+    fs.mkdirSync(outputCodePushFolder, { recursive: true });
+    const outputBundlePath = path.join(outputCodePushFolder, "index.android.bundle");
+    fs.copyFileSync(mainJsBundlePath, outputBundlePath);
+  } else {
+    throw new Error("index.android.bundle not found in APK root folder.");
+  }
+
+  // Save packageManifest.json
+  const manifestPath = path.join(outputFolder, "packageManifest.json");
+  fs.writeFileSync(manifestPath, JSON.stringify(fileHashes, null, 2));
+  log(chalk.cyan(`\nSaved packageManifest.json with ${Object.keys(fileHashes).length} entries.\n`));
+
+  // Create zip archive with packageManifest.json and bundle file
+  const zipPath = path.join(os.tmpdir(), `CodePushBinary-${Date.now()}.zip`);
+  await createZipArchive(outputFolder, zipPath, ["packageManifest.json", "CodePush/index.android.bundle"]);
+
+  return zipPath;
+}
+
+export async function extractMetadataFromIOS(extractFolder, outputFolder) {
+  const payloadFolder = path.join(extractFolder, "Payload");
+  if (!fs.existsSync(payloadFolder)) {
+    throw new Error("Invalid IPA structure: Payload folder not found.");
+  }
+
+  const appFolders = fs.readdirSync(payloadFolder).filter((item) => {
+    const itemPath = path.join(payloadFolder, item);
+    return fs.statSync(itemPath).isDirectory() && item.endsWith(".app");
+  });
+
+  if (appFolders.length === 0) {
+    throw new Error("Invalid IPA structure: No .app folder found in Payload.");
+  }
+
+  const appFolder = path.join(payloadFolder, appFolders[0]);
+  const codePushFolder = path.join(appFolder, "assets");
+
+  const fileHashes: { [key: string]: string } = {};
+
+  if (fs.existsSync(codePushFolder)) {
+    await calculateHashesForDirectory(codePushFolder, appFolder, fileHashes);
+  } else {
+    log(chalk.yellow(`\nWarning: CodePush folder not found in IPA.\n`));
+  }
+
+  const mainJsBundlePath = path.join(appFolder, "main.jsbundle");
+  if (fs.existsSync(mainJsBundlePath)) {
+    log(chalk.cyan(`\nFound main.jsbundle, calculating hash:\n`));
+    const bundleHash = await hashFile(mainJsBundlePath);
+    fileHashes["CodePush/main.jsbundle"] = bundleHash;
+
+    // Copy bundle to output folder
+    const outputCodePushFolder = path.join(outputFolder, "CodePush");
+    fs.mkdirSync(outputCodePushFolder, { recursive: true });
+    const outputBundlePath = path.join(outputCodePushFolder, "main.jsbundle");
+    fs.copyFileSync(mainJsBundlePath, outputBundlePath);
+  } else {
+    throw new Error("main.jsbundle not found in IPA root folder.");
+  }
+
+  // Save packageManifest.json
+  const manifestPath = path.join(outputFolder, "packageManifest.json");
+  fs.writeFileSync(manifestPath, JSON.stringify(fileHashes, null, 2));
+  log(chalk.cyan(`\nSaved packageManifest.json with ${Object.keys(fileHashes).length} entries.\n`));
+
+  // Create zip archive with packageManifest.json and bundle file
+  const zipPath = path.join(os.tmpdir(), `CodePushBinary-${Date.now()}.zip`);
+  await createZipArchive(outputFolder, zipPath, ["packageManifest.json", "CodePush/main.jsbundle"]);
+
+  return zipPath;
+}
+
+async function calculateHashesForDirectory(
+  directoryPath: string,
+  basePath: string,
+  fileHashes: { [key: string]: string }
+) {
+  const items = fs.readdirSync(directoryPath);
+
+  for (const item of items) {
+    const itemPath = path.join(directoryPath, item);
+    const stat = fs.statSync(itemPath);
+
+    if (stat.isDirectory()) {
+      await calculateHashesForDirectory(itemPath, basePath, fileHashes);
+    } else {
+      // Calculate relative path from basePath (app folder) to the file
+      const relativePath = path.relative(basePath, itemPath).replace(/\\/g, "/");
+      const hash = await hashFile(itemPath);
+      const hashKey = `CodePush/${relativePath}`
+      fileHashes[hashKey] = hash;
+      log(chalk.gray(`  ${relativePath}:${hash.substring(0, 8)}...\n`));
+    }
+  }
+}
+
+
+type BinaryHashes = { [p: string]: string };
+
+async function takeHashesFromMetadata(metadataPath: string): Promise<BinaryHashes> {
+  const content = await readFile(metadataPath, "utf-8");
+  const metadata = JSON.parse(content);
+  if (!metadata || !metadata.manifest) {
+    throw new Error("Failed to take manifest from metadata file of APK");
+  }
+
+  return Object.fromEntries(metadata.manifest.map((item) => item.split(":")));
+}
+
+function createZipArchive(sourceFolder: string, zipPath: string, filesToInclude: string[]): Q.Promise<void> {
+  return Q.Promise<void>((resolve, reject) => {
+    const zipFile = new yazl.ZipFile();
+    const writeStream = fs.createWriteStream(zipPath);
+
+    zipFile.outputStream
+      .pipe(writeStream)
+      .on("error", (error: Error) => {
+        reject(error);
+      })
+      .on("close", () => {
+        resolve();
+      });
+
+    for (const file of filesToInclude) {
+      const filePath = path.join(sourceFolder, file);
+      if (fs.existsSync(filePath)) {
+        zipFile.addFile(filePath, file);
+      }
+    }
+
+    zipFile.end();
+  });
+}
+
+function parseAnyPlistFile(plistPath: string): any {
+  const buf = fs.readFileSync(plistPath);
+
+  if (buf.slice(0, 6).toString("ascii") === "bplist") {
+    const arr = bplist.parseBuffer(buf);
+    if (!arr?.length) throw new Error("Empty binary plist");
+    return arr[0];
+  }
+
+  const xml = buf.toString("utf8");
+  return plist.parse(xml);
+}
+
+export async function getIosVersion(extractFolder: string) {
+  const payloadFolder = path.join(extractFolder, "Payload");
+  if (!fs.existsSync(payloadFolder)) {
+    throw new Error("Invalid IPA structure: Payload folder not found.");
+  }
+
+  const appFolders = fs.readdirSync(payloadFolder).filter((item) => {
+    const itemPath = path.join(payloadFolder, item);
+    return fs.statSync(itemPath).isDirectory() && item.endsWith(".app");
+  });
+
+  if (appFolders.length === 0) {
+    throw new Error("Invalid IPA structure: No .app folder found in Payload.");
+  }
+
+  const appFolder = path.join(payloadFolder, appFolders[0]);
+
+  const plistPath = path.join(appFolder, "Info.plist");
+
+  const data = parseAnyPlistFile(plistPath);
+
+  console.log('App Version (Short):', data.CFBundleShortVersionString);
+  console.log('Build Number:', data.CFBundleVersion);
+  console.log('Bundle ID:', data.CFBundleIdentifier);
+
+  return {
+    version: data.CFBundleShortVersionString,
+    build: data.CFBundleVersion
+  };
+}