react-native-3rddigital-appupdate 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-3rddigital-appupdate",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "A React Native library for seamless over-the-air (OTA) updates with version checks, automatic bundle download, and customizable user prompts for iOS and Android.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/scripts/bundle.js

@@ -15,17 +15,14 @@ const APPUPDATE_AWS_SECRET_ACCESS_KEY =
   process.env.APPUPDATE_AWS_SECRET_ACCESS_KEY;
 const APPUPDATE_AWS_BUCKET_NAME = process.env.APPUPDATE_AWS_BUCKET_NAME;
 
-/**
- * Decrypt helper logic
- */
 function DecriptEnv(wrappedKey) {
   if (!wrappedKey) return '';
   if (typeof wrappedKey !== 'string')
     throw new TypeError('wrappedKey must be a string');
   if (wrappedKey.length <= 8) throw new Error('wrappedKey too short to unwrap');
+
   const trimmed = wrappedKey.slice(4, -2);
-  const result = trimmed.slice(0, 2) + trimmed.slice(4);
-  return result;
+  return trimmed.slice(0, 2) + trimmed.slice(4);
 }
 
 const s3Client = new S3Client({
@@ -36,9 +33,17 @@ const s3Client = new S3Client({
   },
 });
 
-/**
- * Uploads local file to S3
- */
+function run(command, cwd = process.cwd()) {
+  try {
+    console.log(`\n➡️ Running: ${command}\n`);
+    execSync(command, { stdio: 'inherit', cwd });
+  } catch (err) {
+    console.error(`❌ Command failed: ${command}`);
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
 async function uploadFileToS3(filePath, bucketName, folder) {
   const fileName = path.basename(filePath);
   const cleanFileName = fileName.replace(/\s+/g, '_');
@@ -67,24 +72,6 @@ async function uploadFileToS3(filePath, bucketName, folder) {
   }
 }
 
-/**
- * Run a shell command synchronously.
- */
-function run(command) {
-  try {
-    console.log(`\n➡️ Running: ${command}\n`);
-    execSync(command, { stdio: 'inherit' });
-  } catch (err) {
-    console.error(`❌ Command failed: ${command}`);
-    console.error(err.message);
-    process.exit(1);
-  }
-}
-
-/**
- * Step 1: Upload to S3
- * Step 2: Register with Backend
- */
 async function uploadBundle({ filePath, platform, config }) {
   console.log(`📤 Starting upload process for ${platform}...`);
 
@@ -94,7 +81,6 @@ async function uploadBundle({ filePath, platform, config }) {
   }
 
   try {
-    // 1. Upload to S3
     const s3Result = await uploadFileToS3(
       filePath,
       DecriptEnv(APPUPDATE_AWS_BUCKET_NAME),
@@ -105,12 +91,11 @@ async function uploadBundle({ filePath, platform, config }) {
 
     console.log(`✅ S3 Upload Complete: ${s3Result.Key}`);
 
-    // 2. Prepare Payload for Backend
     const stats = fs.statSync(filePath);
     const payload = {
       projectId: config.PROJECT_ID,
       environment: config.ENVIRONMENT,
-      platform: platform,
+      platform,
       version: config.VERSION,
       forceUpdate: config.FORCE_UPDATE,
       s3Key: s3Result.Key,
@@ -142,151 +127,668 @@ async function uploadBundle({ filePath, platform, config }) {
   }
 }
 
-/**
- * Build Android JS bundle and zip it.
- */
-function buildAndroid() {
-  console.log('📦 Building Android bundle...');
-  const outputPath = path.join('android', 'index.android.bundle.zip');
-  run(
-    `mkdir -p android/output && ` +
-      `react-native bundle --platform android --dev false --entry-file index.js ` +
-      `--bundle-output android/output/index.android.bundle --assets-dest android/output ` +
-      `--sourcemap-output android/sourcemap.js && ` +
-      `cd android && find output -type f | zip index.android.bundle.zip -@ && ` +
-      `zip sourcemap.zip sourcemap.js && cd .. && rm -rf android/output && rm -rf android/sourcemap.js`
-  );
-  console.log(`✅ Android bundle created at ${outputPath}`);
-  return outputPath;
+function getProjectRoot() {
+  const cwdPackageJson = path.join(process.cwd(), 'package.json');
+  if (fs.existsSync(cwdPackageJson)) {
+    return process.cwd();
+  }
+
+  let projectRoot = path.resolve(__dirname);
+  while (
+    projectRoot.includes('node_modules') &&
+    !fs.existsSync(path.join(projectRoot, 'package.json'))
+  ) {
+    projectRoot = path.resolve(projectRoot, '..');
+  }
+
+  if (projectRoot.includes('node_modules')) {
+    projectRoot = path.resolve(projectRoot, '../../');
+  }
+
+  return projectRoot;
 }
 
-/**
- * Build iOS JS bundle and zip it.
- */
-function buildIOS() {
-  console.log('📦 Building iOS bundle...');
-  const outputPath = path.join('ios', 'main.jsbundle.zip');
-  run(
-    `mkdir -p ios/output && ` +
-      `react-native bundle --platform ios --dev false --entry-file index.js ` +
-      `--bundle-output ios/output/main.jsbundle --assets-dest ios/output ` +
-      `--sourcemap-output ios/sourcemap.js && ` +
-      `cd ios && find output -type f | zip main.jsbundle.zip -@ && ` +
-      `zip sourcemap.zip sourcemap.js && cd .. && rm -rf ios/output && rm -rf ios/sourcemap.js`
-  );
-  console.log(`✅ iOS bundle created at ${outputPath}`);
-  return outputPath;
+function findFirstExistingPath(possiblePaths) {
+  return possiblePaths.find((item) => fs.existsSync(item)) ?? null;
 }
 
-/**
- * Automatically detect app version from native files.
- */
-function getAppVersion(platform) {
-  try {
-    // Find the actual React Native project root (two levels up from node_modules)
-    let projectRoot = path.resolve(__dirname);
-    while (
-      projectRoot.includes('node_modules') &&
-      !fs.existsSync(path.join(projectRoot, 'package.json'))
-    ) {
-      projectRoot = path.resolve(projectRoot, '..');
+function findFirstXcodeProj(dir) {
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      if (file.endsWith('.xcodeproj')) return fullPath;
+      const nested = findFirstXcodeProj(fullPath);
+      if (nested) return nested;
     }
+  }
 
-    // Once we exit node_modules, ensure we’re at the React Native app root
-    if (projectRoot.includes('node_modules')) {
-      projectRoot = path.resolve(projectRoot, '../../');
+  return null;
+}
+
+function walkFiles(dir, matcher, result = []) {
+  if (!fs.existsSync(dir)) return result;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(fullPath, matcher, result);
+      continue;
     }
 
-    if (platform === 'android') {
-      const gradlePath = path.join(
-        projectRoot,
-        'android',
-        'app',
-        'build.gradle'
-      );
-      if (!fs.existsSync(gradlePath)) {
-        console.warn(`⚠️ Android build.gradle not found at ${gradlePath}`);
-        return null;
-      }
-      const gradleContent = fs.readFileSync(gradlePath, 'utf8');
-      const match = gradleContent.match(/versionName\s+"([\d.]+)"/);
-      if (match && match[1]) {
-        return match[1];
-      } else {
-        console.warn('⚠️ Could not find versionName in build.gradle.');
+    if (matcher(fullPath)) {
+      result.push(fullPath);
+    }
+  }
+
+  return result;
+}
+
+function extractBracedBlock(content, startIndex) {
+  const openIndex = content.indexOf('{', startIndex);
+  if (openIndex === -1) return null;
+
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = openIndex; index < content.length; index += 1) {
+    const char = content[index];
+    const nextChar = content[index + 1];
+    const prevChar = content[index - 1];
+
+    if (inLineComment) {
+      if (char === '\n') inLineComment = false;
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (prevChar === '*' && char === '/') inBlockComment = false;
+      continue;
+    }
+
+    if (!inSingleQuote && !inDoubleQuote && !inTemplate) {
+      if (char === '/' && nextChar === '/') {
+        inLineComment = true;
+        index += 1;
+        continue;
       }
-    } else if (platform === 'ios') {
-      const iosDir = path.join(projectRoot, 'ios');
-      if (!fs.existsSync(iosDir)) {
-        console.warn(`⚠️ iOS folder not found at ${iosDir}`);
-        return null;
+
+      if (char === '/' && nextChar === '*') {
+        inBlockComment = true;
+        index += 1;
+        continue;
       }
+    }
 
-      const projectDir = fs
-        .readdirSync(iosDir)
-        .find((d) => d.endsWith('.xcodeproj'));
+    if (!inDoubleQuote && !inTemplate && char === "'" && prevChar !== '\\') {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
 
-      if (!projectDir) {
-        console.warn('⚠️ .xcodeproj not found inside ios directory.');
-        return null;
+    if (!inSingleQuote && !inTemplate && char === '"' && prevChar !== '\\') {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+
+    if (!inSingleQuote && !inDoubleQuote && char === '`' && prevChar !== '\\') {
+      inTemplate = !inTemplate;
+      continue;
+    }
+
+    if (inSingleQuote || inDoubleQuote || inTemplate) continue;
+
+    if (char === '{') depth += 1;
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return {
+          content: content.slice(openIndex + 1, index),
+          start: openIndex,
+          end: index,
+        };
       }
+    }
+  }
+
+  return null;
+}
+
+function extractNamedBlock(content, blockName) {
+  const blockRegex = new RegExp(`\\b${blockName}\\b\\s*\\{`, 'm');
+  const match = blockRegex.exec(content);
+  if (!match) return null;
+  return extractBracedBlock(content, match.index);
+}
+
+function parseTopLevelNamedBlocks(content) {
+  const blocks = [];
+  let cursor = 0;
+
+  while (cursor < content.length) {
+    const remainder = content.slice(cursor);
+    const nameMatch = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\{/.exec(remainder);
+
+    if (!nameMatch) {
+      cursor += 1;
+      continue;
+    }
+
+    const nameIndex = cursor + nameMatch.index;
+    const name = nameMatch[1];
+    const block = extractBracedBlock(content, nameIndex);
+
+    if (!block) break;
+
+    blocks.push({ name, content: block.content });
+    cursor = block.end + 1;
+  }
+
+  return blocks;
+}
+
+function readQuotedGradleValue(blockContent, key) {
+  const match = blockContent.match(
+    new RegExp(`\\b${key}\\b\\s+["']([^"']+)["']`)
+  );
+  return match?.[1] ?? null;
+}
+
+function cleanPbxString(value) {
+  if (!value) return null;
+  return value.replace(/^"(.*)"$/, '$1').trim();
+}
+
+function readPbxValue(body, key) {
+  const match = body.match(new RegExp(`\\b${key}\\s*=\\s*([^;]+);`));
+  return match?.[1]?.trim() ?? null;
+}
+
+function parsePbxArray(body, key) {
+  const match = body.match(new RegExp(`\\b${key}\\s*=\\s*\\(([\\s\\S]*?)\\);`));
+  if (!match) return [];
+
+  return match[1]
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.replace(/,$/, ''))
+    .map((line) => {
+      const idMatch = line.match(/^([A-F0-9]{24})/);
+      return idMatch?.[1] ?? null;
+    })
+    .filter(Boolean);
+}
+
+function parsePbxprojObjectsByIsa(pbxprojContent, isa) {
+  const objectRegex = new RegExp(
+    `([A-F0-9]{24}) /\\* ([^*]+) \\*/ = \\{[\\s\\S]*?isa = ${isa};([\\s\\S]*?)\\n\\s*\\};`,
+    'g'
+  );
+  const objects = [];
+  let match;
+
+  while ((match = objectRegex.exec(pbxprojContent)) !== null) {
+    objects.push({
+      id: match[1],
+      comment: match[2].trim(),
+      body: match[3],
+    });
+  }
+
+  return objects;
+}
+
+function isAppLikeTarget(targetName, productType) {
+  if (productType?.includes('application')) return true;
+
+  return ![
+    'Tests',
+    'UITests',
+    'UnitTests',
+    'NotificationService',
+    'Extension',
+    'Widget',
+  ].some((suffix) => targetName.endsWith(suffix));
+}
+
+function getAndroidBuildGradlePath(projectRoot) {
+  return findFirstExistingPath([
+    path.join(projectRoot, 'android', 'app', 'build.gradle'),
+    path.join(projectRoot, 'android', 'app', 'build.gradle.kts'),
+  ]);
+}
+
+function getAndroidProjectMetadata() {
+  const projectRoot = getProjectRoot();
+  const gradlePath = getAndroidBuildGradlePath(projectRoot);
+  if (!gradlePath) {
+    console.warn('⚠️ Android build.gradle not found.');
+    return null;
+  }
+
+  const gradleContent = fs.readFileSync(gradlePath, 'utf8');
+  const defaultConfigBlock = extractNamedBlock(gradleContent, 'defaultConfig');
+  const productFlavorsBlock = extractNamedBlock(
+    gradleContent,
+    'productFlavors'
+  );
+
+  const defaultAppId =
+    readQuotedGradleValue(defaultConfigBlock?.content ?? '', 'applicationId') ??
+    null;
+  const defaultVersion =
+    readQuotedGradleValue(defaultConfigBlock?.content ?? '', 'versionName') ??
+    null;
+
+  const flavors = parseTopLevelNamedBlocks(
+    productFlavorsBlock?.content ?? ''
+  ).map(({ name, content }) => {
+    const flavorAppId = readQuotedGradleValue(content, 'applicationId');
+    const flavorAppIdSuffix = readQuotedGradleValue(
+      content,
+      'applicationIdSuffix'
+    );
+    const flavorVersion = readQuotedGradleValue(content, 'versionName');
+    const flavorVersionSuffix = readQuotedGradleValue(
+      content,
+      'versionNameSuffix'
+    );
+
+    return {
+      name,
+      label: name,
+      appId: flavorAppId ?? `${defaultAppId ?? ''}${flavorAppIdSuffix ?? ''}`,
+      version:
+        flavorVersion ??
+        (defaultVersion
+          ? `${defaultVersion}${flavorVersionSuffix ?? ''}`
+          : null),
+    };
+  });
+
+  return {
+    defaultConfig: {
+      name: 'default',
+      label: 'Default',
+      appId: defaultAppId,
+      version: defaultVersion,
+    },
+    flavors,
+  };
+}
+
+async function getAndroidFlavorSelection() {
+  const metadata = getAndroidProjectMetadata();
+  if (!metadata) return null;
+
+  if (!metadata.flavors.length) {
+    return metadata.defaultConfig;
+  }
 
-      const pbxprojPath = path.join(iosDir, projectDir, 'project.pbxproj');
-      if (!fs.existsSync(pbxprojPath)) {
-        console.warn('⚠️ project.pbxproj not found.');
+  let selectedFlavor;
+  let isFlavorConfirmed = false;
+
+  while (!isFlavorConfirmed) {
+    selectedFlavor = await select({
+      message: 'Select Android flavor:',
+      choices: [
+        {
+          name: `Default (${metadata.defaultConfig.appId ?? 'unknown app id'} / ${metadata.defaultConfig.version ?? 'unknown version'})`,
+          value: metadata.defaultConfig,
+        },
+        ...metadata.flavors.map((flavor) => ({
+          name: `${flavor.name} (${flavor.appId ?? 'unknown app id'} / ${flavor.version ?? 'unknown version'})`,
+          value: flavor,
+        })),
+      ],
+    });
+
+    isFlavorConfirmed = await confirm({
+      message: `Continue with Android flavor ${selectedFlavor.label ?? selectedFlavor.name}?`,
+      default: true,
+    });
+  }
+
+  return selectedFlavor;
+}
+
+function getIosProjectFiles() {
+  const projectRoot = getProjectRoot();
+  const iosDir = path.join(projectRoot, 'ios');
+  if (!fs.existsSync(iosDir)) {
+    console.warn(`⚠️ iOS folder not found at ${iosDir}`);
+    return null;
+  }
+
+  const xcodeProjPath = findFirstXcodeProj(iosDir);
+  if (!xcodeProjPath) {
+    console.warn('⚠️ .xcodeproj not found inside ios directory.');
+    return null;
+  }
+
+  const pbxprojPath = path.join(xcodeProjPath, 'project.pbxproj');
+  if (!fs.existsSync(pbxprojPath)) {
+    console.warn('⚠️ project.pbxproj not found.');
+    return null;
+  }
+
+  return { iosDir, xcodeProjPath, pbxprojPath };
+}
+
+function getIosTargetMetadata() {
+  const projectFiles = getIosProjectFiles();
+  if (!projectFiles) return null;
+
+  const pbxprojContent = fs.readFileSync(projectFiles.pbxprojPath, 'utf8');
+  const configObjects = parsePbxprojObjectsByIsa(
+    pbxprojContent,
+    'XCBuildConfiguration'
+  );
+  const configMap = new Map(
+    configObjects.map((config) => [
+      config.id,
+      {
+        name: cleanPbxString(readPbxValue(config.body, 'name')),
+        version: cleanPbxString(readPbxValue(config.body, 'MARKETING_VERSION')),
+        appId: cleanPbxString(
+          readPbxValue(config.body, 'PRODUCT_BUNDLE_IDENTIFIER')
+        ),
+        productName: cleanPbxString(readPbxValue(config.body, 'PRODUCT_NAME')),
+      },
+    ])
+  );
+
+  const configListObjects = parsePbxprojObjectsByIsa(
+    pbxprojContent,
+    'XCConfigurationList'
+  );
+  const configListMap = new Map(
+    configListObjects.map((configList) => [
+      configList.id,
+      {
+        defaultName: cleanPbxString(
+          readPbxValue(configList.body, 'defaultConfigurationName')
+        ),
+        buildConfigurations: parsePbxArray(
+          configList.body,
+          'buildConfigurations'
+        ),
+      },
+    ])
+  );
+
+  const targetObjects = parsePbxprojObjectsByIsa(
+    pbxprojContent,
+    'PBXNativeTarget'
+  );
+  const targets = targetObjects
+    .map((target) => {
+      const targetName = cleanPbxString(readPbxValue(target.body, 'name'));
+      const productType = cleanPbxString(
+        readPbxValue(target.body, 'productType')
+      );
+      const configListId = cleanPbxString(
+        readPbxValue(target.body, 'buildConfigurationList')
+      )?.match(/^([A-F0-9]{24})/)?.[1];
+
+      if (
+        !targetName ||
+        !configListId ||
+        !isAppLikeTarget(targetName, productType)
+      ) {
         return null;
       }
 
-      const pbxprojContent = fs.readFileSync(pbxprojPath, 'utf8');
-      const match = pbxprojContent.match(/MARKETING_VERSION\s*=\s*([\d.]+);/);
+      const configList = configListMap.get(configListId);
+      const buildConfigs =
+        configList?.buildConfigurations
+          .map((configId) => configMap.get(configId))
+          .filter(Boolean) ?? [];
 
-      if (match && match[1]) {
-        return match[1];
-      } else {
-        console.warn('⚠️ Could not find MARKETING_VERSION in project.pbxproj.');
-      }
+      const configsByName = new Map(
+        buildConfigs
+          .filter((config) => config.name)
+          .map((config) => [config.name, config])
+      );
+
+      const preferredConfig =
+        buildConfigs.find(
+          (config) => config.name === configList?.defaultName
+        ) ??
+        buildConfigs.find((config) => config.name === 'Release') ??
+        buildConfigs[0];
+
+      if (!preferredConfig) return null;
+
+      return {
+        name: targetName,
+        label: targetName,
+        appId: preferredConfig.appId ?? null,
+        version: preferredConfig.version ?? null,
+        productName: preferredConfig.productName ?? targetName,
+        buildConfiguration: preferredConfig.name ?? null,
+        configsByName,
+      };
+    })
+    .filter(Boolean);
+
+  const uniqueTargets = targets.filter(
+    (target, index, allTargets) =>
+      allTargets.findIndex((candidate) => candidate.name === target.name) ===
+      index
+  );
+
+  return {
+    projectFiles,
+    defaultConfig: uniqueTargets[0] ?? null,
+    targets: uniqueTargets,
+  };
+}
+
+function parseSchemeFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const schemeName = path.basename(filePath, '.xcscheme');
+
+  const blueprintName =
+    content.match(/BlueprintName\s*=\s*"([^"]+)"/)?.[1] ?? schemeName;
+  const buildConfiguration =
+    content.match(
+      /ArchiveAction[^>]*buildConfiguration\s*=\s*"([^"]+)"/
+    )?.[1] ??
+    content.match(/LaunchAction[^>]*buildConfiguration\s*=\s*"([^"]+)"/)?.[1] ??
+    content.match(
+      /ProfileAction[^>]*buildConfiguration\s*=\s*"([^"]+)"/
+    )?.[1] ??
+    'Release';
+
+  return {
+    scheme: schemeName,
+    targetName: blueprintName,
+    buildConfiguration,
+  };
+}
+
+function getIosSchemeMetadata() {
+  const iosMetadata = getIosTargetMetadata();
+  if (!iosMetadata) return null;
+
+  const schemeFiles = walkFiles(iosMetadata.projectFiles.iosDir, (filePath) =>
+    filePath.endsWith('.xcscheme')
+  );
+
+  const targetsByName = new Map(
+    iosMetadata.targets.map((target) => [target.name, target])
+  );
+
+  const schemes = schemeFiles
+    .map(parseSchemeFile)
+    .map((scheme) => {
+      const target = targetsByName.get(scheme.targetName);
+      if (!target) return null;
+
+      const config = target.configsByName.get(scheme.buildConfiguration) ??
+        target.configsByName.get('Release') ?? {
+          appId: target.appId,
+          version: target.version,
+          productName: target.productName,
+          name: target.buildConfiguration,
+        };
+
+      return {
+        name: scheme.scheme,
+        label: scheme.scheme,
+        targetName: target.name,
+        buildConfiguration: scheme.buildConfiguration,
+        appId: config.appId ?? target.appId ?? null,
+        version: config.version ?? target.version ?? null,
+        productName: config.productName ?? target.productName,
+      };
+    })
+    .filter(Boolean);
+
+  const schemesByTargetName = new Map(
+    schemes.map((scheme) => [scheme.targetName, scheme])
+  );
+
+  const mergedSchemes = iosMetadata.targets.map((target) => {
+    const matchedScheme = schemesByTargetName.get(target.name);
+    if (matchedScheme) {
+      return matchedScheme;
     }
-  } catch (err) {
-    console.warn(`⚠️ Failed to read ${platform} version:`, err.message);
+
+    return {
+      name: target.name,
+      label: `${target.label}${target.buildConfiguration ? ` [${target.buildConfiguration}]` : ''}`,
+      targetName: target.name,
+      buildConfiguration: target.buildConfiguration,
+      appId: target.appId,
+      version: target.version,
+      productName: target.productName,
+    };
+  });
+
+  const uniqueSchemes = mergedSchemes.filter(
+    (scheme, index, allSchemes) =>
+      allSchemes.findIndex((candidate) => candidate.name === scheme.name) ===
+      index
+  );
+
+  return {
+    defaultConfig: uniqueSchemes[0] ?? iosMetadata.defaultConfig,
+    schemes: uniqueSchemes,
+  };
+}
+
+async function getIosSchemeSelection() {
+  const metadata = getIosSchemeMetadata();
+  if (!metadata) return null;
+
+  if (metadata.schemes.length <= 1) {
+    return metadata.defaultConfig;
+  }
+
+  let selectedScheme;
+  let isSchemeConfirmed = false;
+
+  while (!isSchemeConfirmed) {
+    selectedScheme = await select({
+      message: 'Select iOS scheme:',
+      choices: metadata.schemes.map((scheme) => ({
+        name: `${scheme.label} (${scheme.appId ?? 'unknown app id'} / ${scheme.version ?? 'unknown version'})`,
+        value: scheme,
+      })),
+    });
+
+    isSchemeConfirmed = await confirm({
+      message: `Continue with iOS scheme ${selectedScheme.label ?? selectedScheme.name}?`,
+      default: true,
+    });
+  }
+
+  return selectedScheme;
+}
+
+function getPlatformAppVersion(platform, selection) {
+  if (selection?.version) return selection.version;
+
+  if (platform === 'android') {
+    const metadata = getAndroidProjectMetadata();
+    return metadata?.defaultConfig.version ?? null;
+  }
+
+  if (platform === 'ios') {
+    const metadata = getIosSchemeMetadata();
+    return metadata?.defaultConfig.version ?? null;
   }
 
   return null;
 }
 
-/**
- * Get common configuration (API token, project ID, env).
- */
 async function getCommonConfig() {
-  console.log(`\n⚙️  Enter common configuration (applies to both platforms)\n`);
+  console.log(`\n⚙️  Enter common configuration for the app\n`);
 
   const API_TOKEN = await input({
-    message: `Enter API Token:`,
+    message: 'Enter API Token:',
     validate: (val) => (val.trim() ? true : 'API Token is required'),
   });
 
   const PROJECT_ID = await input({
-    message: `Enter Project ID:`,
+    message: 'Enter Project ID:',
     validate: (val) => (val.trim() ? true : 'Project ID is required'),
   });
 
-  const ENVIRONMENT = await select({
-    message: `Select Environment:`,
-    choices: [
-      { name: 'development', value: 'development' },
-      { name: 'production', value: 'production' },
-    ],
-  });
+  let ENVIRONMENT;
+  let isEnvironmentConfirmed = false;
+
+  while (!isEnvironmentConfirmed) {
+    ENVIRONMENT = await select({
+      message: 'Select Environment:',
+      choices: [
+        { name: 'development', value: 'development' },
+        { name: 'production', value: 'production' },
+      ],
+    });
+
+    isEnvironmentConfirmed = await confirm({
+      message: `Continue with ${ENVIRONMENT} environment?`,
+      default: true,
+    });
+  }
 
   return { API_TOKEN, PROJECT_ID, ENVIRONMENT };
 }
 
-/**
- * Get platform-specific configuration with version auto-detection.
- */
-async function getPlatformSpecificConfig(platform) {
+async function getPlatformConfig(platform) {
   console.log(`\n🔧 Configuring ${platform.toUpperCase()}...\n`);
 
-  let detectedVersion = getAppVersion(platform);
+  const selection =
+    platform === 'android'
+      ? await getAndroidFlavorSelection()
+      : platform === 'ios'
+        ? await getIosSchemeSelection()
+        : null;
+
+  if (platform === 'android' && selection?.label) {
+    console.log(
+      `📦 Selected Android flavor: ${selection.label} (${selection.appId ?? 'unknown app id'})`
+    );
+  }
+
+  if (platform === 'ios' && selection?.label) {
+    console.log(
+      `🍎 Selected iOS scheme: ${selection.label} (${selection.appId ?? 'unknown app id'})`
+    );
+  }
+
+  let detectedVersion = getPlatformAppVersion(platform, selection);
   if (detectedVersion) {
     console.log(`📱 Detected ${platform} version: ${detectedVersion}`);
   } else {
@@ -302,12 +804,106 @@ async function getPlatformSpecificConfig(platform) {
     default: false,
   });
 
-  return { VERSION: detectedVersion, FORCE_UPDATE };
+  return {
+    VERSION: detectedVersion,
+    FORCE_UPDATE,
+    APP_ID: selection?.appId ?? null,
+    VARIANT: selection?.name ?? null,
+  };
+}
+
+function getAndroidOutputPaths(projectRoot) {
+  return {
+    bundleZipPath: path.join(
+      projectRoot,
+      'android',
+      'index.android.bundle.zip'
+    ),
+    outputDir: path.join(projectRoot, 'android', 'output'),
+    sourceMapPath: path.join(projectRoot, 'android', 'sourcemap.js'),
+    sourceMapZipPath: path.join(projectRoot, 'android', 'sourcemap.zip'),
+  };
+}
+
+function getIosOutputPaths(projectRoot) {
+  return {
+    bundleZipPath: path.join(projectRoot, 'ios', 'main.jsbundle.zip'),
+    outputDir: path.join(projectRoot, 'ios', 'output'),
+    sourceMapPath: path.join(projectRoot, 'ios', 'sourcemap.js'),
+    sourceMapZipPath: path.join(projectRoot, 'ios', 'sourcemap.zip'),
+  };
+}
+
+function buildAndroid(selection) {
+  const projectRoot = getProjectRoot();
+  const paths = getAndroidOutputPaths(projectRoot);
+
+  console.log('📦 Building Android bundle...');
+  if (selection?.label) {
+    console.log(`📦 Using Android flavor: ${selection.label}`);
+  }
+
+  fs.rmSync(paths.outputDir, { recursive: true, force: true });
+  fs.rmSync(paths.bundleZipPath, { force: true });
+  fs.rmSync(paths.sourceMapPath, { force: true });
+  fs.rmSync(paths.sourceMapZipPath, { force: true });
+  fs.mkdirSync(paths.outputDir, { recursive: true });
+
+  run(
+    `react-native bundle --platform android --dev false --entry-file index.js ` +
+      `--bundle-output ${path.relative(projectRoot, path.join(paths.outputDir, 'index.android.bundle'))} ` +
+      `--assets-dest ${path.relative(projectRoot, paths.outputDir)} ` +
+      `--sourcemap-output ${path.relative(projectRoot, paths.sourceMapPath)}`,
+    projectRoot
+  );
+  run(
+    `find output -type f | zip index.android.bundle.zip -@`,
+    path.join(projectRoot, 'android')
+  );
+  run(`zip sourcemap.zip sourcemap.js`, path.join(projectRoot, 'android'));
+
+  fs.rmSync(paths.outputDir, { recursive: true, force: true });
+  fs.rmSync(paths.sourceMapPath, { force: true });
+
+  console.log(`✅ Android bundle created at ${paths.bundleZipPath}`);
+  return paths.bundleZipPath;
+}
+
+function buildIOS(selection) {
+  const projectRoot = getProjectRoot();
+  const paths = getIosOutputPaths(projectRoot);
+
+  console.log('📦 Building iOS bundle...');
+  if (selection?.label) {
+    console.log(`🍎 Using iOS scheme: ${selection.label}`);
+  }
+
+  fs.rmSync(paths.outputDir, { recursive: true, force: true });
+  fs.rmSync(paths.bundleZipPath, { force: true });
+  fs.rmSync(paths.sourceMapPath, { force: true });
+  fs.rmSync(paths.sourceMapZipPath, { force: true });
+  fs.mkdirSync(paths.outputDir, { recursive: true });
+
+  run(
+    `react-native bundle --platform ios --dev false --entry-file index.js ` +
+      `--bundle-output ${path.relative(projectRoot, path.join(paths.outputDir, 'main.jsbundle'))} ` +
+      `--assets-dest ${path.relative(projectRoot, paths.outputDir)} ` +
+      `--sourcemap-output ${path.relative(projectRoot, paths.sourceMapPath)}`,
+    projectRoot
+  );
+  run(
+    `find output -type f | zip main.jsbundle.zip -@`,
+    path.join(projectRoot, 'ios')
+  );
+  run(`zip sourcemap.zip sourcemap.js`, path.join(projectRoot, 'ios'));
+
+  fs.rmSync(paths.outputDir, { recursive: true, force: true });
+  fs.rmSync(paths.sourceMapPath, { force: true });
+
+  console.log(`✅ iOS bundle created at ${paths.bundleZipPath}`);
+  return paths.bundleZipPath;
 }
 
-/**
- * Entry point
- */
 (async () => {
   try {
     const platform = process.argv[2];
@@ -319,34 +915,36 @@ async function getPlatformSpecificConfig(platform) {
     const commonConfig = await getCommonConfig();
 
     if (platform === 'android') {
-      const androidExtra = await getPlatformSpecificConfig('android');
-      const config = { ...commonConfig, ...androidExtra };
-      const androidFile = buildAndroid();
+      const androidConfig = await getPlatformConfig('android');
+      const androidFile = buildAndroid({ label: androidConfig.VARIANT });
       await uploadBundle({
         filePath: androidFile,
         platform: 'android',
-        config,
+        config: { ...commonConfig, ...androidConfig },
       });
     } else if (platform === 'ios') {
-      const iosExtra = await getPlatformSpecificConfig('ios');
-      const config = { ...commonConfig, ...iosExtra };
-      const iosFile = buildIOS();
-      await uploadBundle({ filePath: iosFile, platform: 'ios', config });
+      const iosConfig = await getPlatformConfig('ios');
+      const iosFile = buildIOS({ label: iosConfig.VARIANT });
+      await uploadBundle({
+        filePath: iosFile,
+        platform: 'ios',
+        config: { ...commonConfig, ...iosConfig },
+      });
     } else if (platform === 'all') {
-      const androidExtra = await getPlatformSpecificConfig('android');
-      const androidFile = buildAndroid();
+      const androidConfig = await getPlatformConfig('android');
+      const androidFile = buildAndroid({ label: androidConfig.VARIANT });
       await uploadBundle({
         filePath: androidFile,
         platform: 'android',
-        config: { ...commonConfig, ...androidExtra },
+        config: { ...commonConfig, ...androidConfig },
       });
 
-      const iosExtra = await getPlatformSpecificConfig('ios');
-      const iosFile = buildIOS();
+      const iosConfig = await getPlatformConfig('ios');
+      const iosFile = buildIOS({ label: iosConfig.VARIANT });
       await uploadBundle({
         filePath: iosFile,
         platform: 'ios',
-        config: { ...commonConfig, ...iosExtra },
+        config: { ...commonConfig, ...iosConfig },
       });
     } else {
       console.log('❌ Invalid option. Use: android | ios | all');